From dd50a9b13ec22d7871fbd9a6dd6e8eb68803f2de Mon Sep 17 00:00:00 2001
From: "deepsource-autofix[bot]"
<62050782+deepsource-autofix[bot]@users.noreply.github.com>
Date: Sun, 8 Nov 2020 21:48:49 +0000
Subject: [PATCH] Remove assert statement from non-test files
---
aiogram/dispatcher/dispatcher.py | 7 +-
tests/conftest.py | 3 +-
tests/contrib/fsm_storage/test_redis.py | 15 +-
tests/test_bot.py | 207 ++++++++++++------
tests/test_bot/test_api.py | 3 +-
tests/test_bot/test_session.py | 45 ++--
tests/test_dispatcher.py | 3 +-
.../test_filters/test_builtin.py | 12 +-
.../test_filters/test_state.py | 3 +-
tests/test_dispatcher/test_handler.py | 15 +-
tests/test_filters.py | 24 +-
tests/test_states_group.py | 82 ++++---
tests/test_utils/test_auth_widget.py | 15 +-
tests/test_utils/test_deep_linking.py | 12 +-
tests/test_utils/test_deprecated.py | 6 +-
tests/test_utils/test_helper.py | 6 +-
tests/test_utils/test_markdown.py | 6 +-
tests/test_utils/test_text_decorations.py | 10 +-
tests/types/test_animation.py | 45 ++--
tests/types/test_chat.py | 93 +++++---
tests/types/test_chat_member.py | 117 ++++++----
tests/types/test_document.py | 33 ++-
tests/types/test_game.py | 30 ++-
tests/types/test_input_media.py | 30 ++-
tests/types/test_message.py | 39 ++--
tests/types/test_photo.py | 30 ++-
tests/types/test_reply_keyboard.py | 6 +-
tests/types/test_update.py | 15 +-
tests/types/test_user.py | 48 ++--
29 files changed, 637 insertions(+), 323 deletions(-)
diff --git a/aiogram/dispatcher/dispatcher.py b/aiogram/dispatcher/dispatcher.py
index 978c4426..b074d60e 100644
--- a/aiogram/dispatcher/dispatcher.py
+++ b/aiogram/dispatcher/dispatcher.py
@@ -31,10 +31,11 @@ DEFAULT_RATE_LIMIT = .1
def _ensure_loop(x: "asyncio.AbstractEventLoop"):
- assert isinstance(
+ if not isinstance(
x, asyncio.AbstractEventLoop
- ), f"Loop must be the implementation of {asyncio.AbstractEventLoop!r}, " \
- f"not {type(x)!r}"
+ ):
+ raise AssertionError(f"Loop must be the implementation of {asyncio.AbstractEventLoop!r}, " \
+ f"not {type(x)!r}")
class Dispatcher(DataMixin, ContextInstanceMixin):
diff --git a/tests/conftest.py b/tests/conftest.py
index 297fbd28..466e9490 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -22,7 +22,8 @@ def pytest_collection_modifyitems(config, items):
return
try:
address, options = aioredis.util.parse_url(redis_uri)
- assert isinstance(address, tuple), "Only redis and rediss schemas are supported, eg redis://foo."
+ if not isinstance(address, tuple):
+ raise AssertionError("Only redis and rediss schemas are supported, eg redis://foo.")
except AssertionError as e:
raise UsageError(f"Invalid redis URI {redis_uri!r}: {e}")
diff --git a/tests/contrib/fsm_storage/test_redis.py b/tests/contrib/fsm_storage/test_redis.py
index 527c905e..40f18cad 100644
--- a/tests/contrib/fsm_storage/test_redis.py
+++ b/tests/contrib/fsm_storage/test_redis.py
@@ -19,15 +19,20 @@ async def store(redis_options):
class TestRedisStorage2:
@pytest.mark.asyncio
async def test_set_get(self, store):
- assert await store.get_data(chat='1234') == {}
+ if await store.get_data(chat='1234') != {}:
+ raise AssertionError
await store.set_data(chat='1234', data={'foo': 'bar'})
- assert await store.get_data(chat='1234') == {'foo': 'bar'}
+ if await store.get_data(chat='1234') != {'foo': 'bar'}:
+ raise AssertionError
@pytest.mark.asyncio
async def test_close_and_open_connection(self, store):
await store.set_data(chat='1234', data={'foo': 'bar'})
- assert await store.get_data(chat='1234') == {'foo': 'bar'}
+ if await store.get_data(chat='1234') != {'foo': 'bar'}:
+ raise AssertionError
pool_id = id(store._redis)
await store.close()
- assert await store.get_data(chat='1234') == {'foo': 'bar'} # new pool was opened at this point
- assert id(store._redis) != pool_id
+ if await store.get_data(chat='1234') != {'foo': 'bar'}:
+ raise AssertionError
+ if id(store._redis) == pool_id:
+ raise AssertionError
diff --git a/tests/test_bot.py b/tests/test_bot.py
index 54cd0c47..462bd48e 100644
--- a/tests/test_bot.py
+++ b/tests/test_bot.py
@@ -22,7 +22,8 @@ async def test_get_me(bot: Bot, event_loop):
async with FakeTelegram(message_data=USER, loop=event_loop):
result = await bot.me
- assert result == user
+ if result != user:
+ raise AssertionError
async def test_log_out(bot: Bot, event_loop):
@@ -30,7 +31,8 @@ async def test_log_out(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.log_out()
- assert result is True
+ if result is not True:
+ raise AssertionError
async def test_close_bot(bot: Bot, event_loop):
@@ -38,7 +40,8 @@ async def test_close_bot(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.close_bot()
- assert result is True
+ if result is not True:
+ raise AssertionError
async def test_send_message(bot: Bot, event_loop):
@@ -48,7 +51,8 @@ async def test_send_message(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE, loop=event_loop):
result = await bot.send_message(chat_id=msg.chat.id, text=msg.text)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_forward_message(bot: Bot, event_loop):
@@ -59,7 +63,8 @@ async def test_forward_message(bot: Bot, event_loop):
async with FakeTelegram(message_data=FORWARDED_MESSAGE, loop=event_loop):
result = await bot.forward_message(chat_id=msg.chat.id, from_chat_id=msg.forward_from_chat.id,
message_id=msg.forward_from_message_id)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_photo(bot: Bot, event_loop):
@@ -71,7 +76,8 @@ async def test_send_photo(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_PHOTO, loop=event_loop):
result = await bot.send_photo(msg.chat.id, photo=photo.file_id, caption=msg.caption,
parse_mode=types.ParseMode.HTML, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_audio(bot: Bot, event_loop):
@@ -83,7 +89,8 @@ async def test_send_audio(bot: Bot, event_loop):
result = await bot.send_audio(chat_id=msg.chat.id, audio=msg.audio.file_id, caption=msg.caption,
parse_mode=types.ParseMode.HTML, duration=msg.audio.duration,
performer=msg.audio.performer, title=msg.audio.title, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_document(bot: Bot, event_loop):
@@ -94,7 +101,8 @@ async def test_send_document(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_DOCUMENT, loop=event_loop):
result = await bot.send_document(chat_id=msg.chat.id, document=msg.document.file_id, caption=msg.caption,
parse_mode=types.ParseMode.HTML, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_video(bot: Bot, event_loop):
@@ -108,7 +116,8 @@ async def test_send_video(bot: Bot, event_loop):
width=video.width, height=video.height, caption=msg.caption,
parse_mode=types.ParseMode.HTML, supports_streaming=True,
disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_voice(bot: Bot, event_loop):
@@ -121,7 +130,8 @@ async def test_send_voice(bot: Bot, event_loop):
result = await bot.send_voice(chat_id=msg.chat.id, voice=voice.file_id, caption=msg.caption,
parse_mode=types.ParseMode.HTML, duration=voice.duration,
disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_video_note(bot: Bot, event_loop):
@@ -134,7 +144,8 @@ async def test_send_video_note(bot: Bot, event_loop):
result = await bot.send_video_note(chat_id=msg.chat.id, video_note=video_note.file_id,
duration=video_note.duration, length=video_note.length,
disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_media_group(bot: Bot, event_loop):
@@ -146,8 +157,10 @@ async def test_send_media_group(bot: Bot, event_loop):
async with FakeTelegram(message_data=[MESSAGE_WITH_MEDIA_GROUP, MESSAGE_WITH_MEDIA_GROUP], loop=event_loop):
result = await bot.send_media_group(msg.chat.id, media=media, disable_notification=False)
- assert len(result) == len(media)
- assert result.pop().media_group_id
+ if len(result) != len(media):
+ raise AssertionError
+ if not result.pop().media_group_id:
+ raise AssertionError
async def test_send_location(bot: Bot, event_loop):
@@ -159,7 +172,8 @@ async def test_send_location(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_LOCATION, loop=event_loop):
result = await bot.send_location(msg.chat.id, latitude=location.latitude, longitude=location.longitude,
live_period=10, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_edit_message_live_location_by_bot(bot: Bot, event_loop):
@@ -172,7 +186,8 @@ async def test_edit_message_live_location_by_bot(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_LOCATION, loop=event_loop):
result = await bot.edit_message_live_location(chat_id=msg.chat.id, message_id=msg.message_id,
latitude=location.latitude, longitude=location.longitude)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_edit_message_live_location_by_user(bot: Bot, event_loop):
@@ -185,7 +200,8 @@ async def test_edit_message_live_location_by_user(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.edit_message_live_location(chat_id=msg.chat.id, message_id=msg.message_id,
latitude=location.latitude, longitude=location.longitude)
- assert isinstance(result, bool) and result is True
+ if not (isinstance(result, bool) and result is True):
+ raise AssertionError
async def test_stop_message_live_location_by_bot(bot: Bot, event_loop):
@@ -196,7 +212,8 @@ async def test_stop_message_live_location_by_bot(bot: Bot, event_loop):
# stopping bot message
async with FakeTelegram(message_data=MESSAGE_WITH_LOCATION, loop=event_loop):
result = await bot.stop_message_live_location(chat_id=msg.chat.id, message_id=msg.message_id)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_stop_message_live_location_by_user(bot: Bot, event_loop):
@@ -207,8 +224,10 @@ async def test_stop_message_live_location_by_user(bot: Bot, event_loop):
# stopping user's message
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.stop_message_live_location(chat_id=msg.chat.id, message_id=msg.message_id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_send_venue(bot: Bot, event_loop):
@@ -222,7 +241,8 @@ async def test_send_venue(bot: Bot, event_loop):
result = await bot.send_venue(msg.chat.id, latitude=location.latitude, longitude=location.longitude,
title=venue.title, address=venue.address, foursquare_id=venue.foursquare_id,
disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_contact(bot: Bot, event_loop):
@@ -234,7 +254,8 @@ async def test_send_contact(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_CONTACT, loop=event_loop):
result = await bot.send_contact(msg.chat.id, phone_number=contact.phone_number, first_name=contact.first_name,
last_name=contact.last_name, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_dice(bot: Bot, event_loop):
@@ -244,7 +265,8 @@ async def test_send_dice(bot: Bot, event_loop):
async with FakeTelegram(message_data=MESSAGE_WITH_DICE, loop=event_loop):
result = await bot.send_dice(msg.chat.id, disable_notification=False)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_send_chat_action(bot: Bot, event_loop):
@@ -254,8 +276,10 @@ async def test_send_chat_action(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.send_chat_action(chat_id=chat.id, action=types.ChatActions.TYPING)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_get_user_profile_photo(bot: Bot, event_loop):
@@ -265,7 +289,8 @@ async def test_get_user_profile_photo(bot: Bot, event_loop):
async with FakeTelegram(message_data=USER_PROFILE_PHOTOS, loop=event_loop):
result = await bot.get_user_profile_photos(user_id=user.id, offset=1, limit=1)
- assert isinstance(result, types.UserProfilePhotos)
+ if not isinstance(result, types.UserProfilePhotos):
+ raise AssertionError
async def test_get_file(bot: Bot, event_loop):
@@ -275,7 +300,8 @@ async def test_get_file(bot: Bot, event_loop):
async with FakeTelegram(message_data=FILE, loop=event_loop):
result = await bot.get_file(file_id=file.file_id)
- assert isinstance(result, types.File)
+ if not isinstance(result, types.File):
+ raise AssertionError
async def test_kick_chat_member(bot: Bot, event_loop):
@@ -286,8 +312,10 @@ async def test_kick_chat_member(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.kick_chat_member(chat_id=chat.id, user_id=user.id, until_date=123)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_unban_chat_member(bot: Bot, event_loop):
@@ -298,8 +326,10 @@ async def test_unban_chat_member(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.unban_chat_member(chat_id=chat.id, user_id=user.id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_restrict_chat_member(bot: Bot, event_loop):
@@ -318,8 +348,10 @@ async def test_restrict_chat_member(bot: Bot, event_loop):
can_send_messages=False,
can_send_other_messages=False
), until_date=123)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_promote_chat_member(bot: Bot, event_loop):
@@ -333,8 +365,10 @@ async def test_promote_chat_member(bot: Bot, event_loop):
can_delete_messages=True, can_edit_messages=True,
can_invite_users=True, can_pin_messages=True, can_post_messages=True,
can_promote_members=True, can_restrict_members=True)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_export_chat_invite_link(bot: Bot, event_loop):
@@ -344,7 +378,8 @@ async def test_export_chat_invite_link(bot: Bot, event_loop):
async with FakeTelegram(message_data=INVITE_LINK, loop=event_loop):
result = await bot.export_chat_invite_link(chat_id=chat.id)
- assert result == INVITE_LINK
+ if result != INVITE_LINK:
+ raise AssertionError
async def test_delete_chat_photo(bot: Bot, event_loop):
@@ -354,8 +389,10 @@ async def test_delete_chat_photo(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.delete_chat_photo(chat_id=chat.id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_set_chat_title(bot: Bot, event_loop):
@@ -365,8 +402,10 @@ async def test_set_chat_title(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.set_chat_title(chat_id=chat.id, title='Test title')
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_set_chat_description(bot: Bot, event_loop):
@@ -376,8 +415,10 @@ async def test_set_chat_description(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.set_chat_description(chat_id=chat.id, description='Test description')
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_pin_chat_message(bot: Bot, event_loop):
@@ -388,8 +429,10 @@ async def test_pin_chat_message(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.pin_chat_message(chat_id=message.chat.id, message_id=message.message_id,
disable_notification=False)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_unpin_chat_message(bot: Bot, event_loop):
@@ -399,8 +442,10 @@ async def test_unpin_chat_message(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.unpin_chat_message(chat_id=chat.id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_leave_chat(bot: Bot, event_loop):
@@ -410,8 +455,10 @@ async def test_leave_chat(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.leave_chat(chat_id=chat.id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_get_chat(bot: Bot, event_loop):
@@ -421,7 +468,8 @@ async def test_get_chat(bot: Bot, event_loop):
async with FakeTelegram(message_data=CHAT, loop=event_loop):
result = await bot.get_chat(chat_id=chat.id)
- assert result == chat
+ if result != chat:
+ raise AssertionError
async def test_get_chat_administrators(bot: Bot, event_loop):
@@ -432,8 +480,10 @@ async def test_get_chat_administrators(bot: Bot, event_loop):
async with FakeTelegram(message_data=[CHAT_MEMBER, CHAT_MEMBER], loop=event_loop):
result = await bot.get_chat_administrators(chat_id=chat.id)
- assert result[0] == member
- assert len(result) == 2
+ if result[0] != member:
+ raise AssertionError
+ if len(result) != 2:
+ raise AssertionError
async def test_get_chat_members_count(bot: Bot, event_loop):
@@ -444,7 +494,8 @@ async def test_get_chat_members_count(bot: Bot, event_loop):
async with FakeTelegram(message_data=count, loop=event_loop):
result = await bot.get_chat_members_count(chat_id=chat.id)
- assert result == count
+ if result != count:
+ raise AssertionError
async def test_get_chat_member(bot: Bot, event_loop):
@@ -455,8 +506,10 @@ async def test_get_chat_member(bot: Bot, event_loop):
async with FakeTelegram(message_data=CHAT_MEMBER, loop=event_loop):
result = await bot.get_chat_member(chat_id=chat.id, user_id=member.user.id)
- assert isinstance(result, types.ChatMember)
- assert result == member
+ if not isinstance(result, types.ChatMember):
+ raise AssertionError
+ if result != member:
+ raise AssertionError
async def test_set_chat_sticker_set(bot: Bot, event_loop):
@@ -466,8 +519,10 @@ async def test_set_chat_sticker_set(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.set_chat_sticker_set(chat_id=chat.id, sticker_set_name='aiogram_stickers')
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_delete_chat_sticker_set(bot: Bot, event_loop):
@@ -477,8 +532,10 @@ async def test_delete_chat_sticker_set(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.delete_chat_sticker_set(chat_id=chat.id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_answer_callback_query(bot: Bot, event_loop):
@@ -486,8 +543,10 @@ async def test_answer_callback_query(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.answer_callback_query(callback_query_id='QuERyId', text='Test Answer')
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_set_my_commands(bot: Bot, event_loop):
@@ -497,8 +556,10 @@ async def test_set_my_commands(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
commands = [types.BotCommand(**BOT_COMMAND), types.BotCommand(**BOT_COMMAND)]
result = await bot.set_my_commands(commands)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_get_my_commands(bot: Bot, event_loop):
@@ -508,8 +569,10 @@ async def test_get_my_commands(bot: Bot, event_loop):
commands = [command, command]
async with FakeTelegram(message_data=commands, loop=event_loop):
result = await bot.get_my_commands()
- assert isinstance(result, list)
- assert all(isinstance(command, types.BotCommand) for command in result)
+ if not isinstance(result, list):
+ raise AssertionError
+ if not all(isinstance(command, types.BotCommand) for command in result):
+ raise AssertionError
async def test_edit_message_text_by_bot(bot: Bot, event_loop):
@@ -520,7 +583,8 @@ async def test_edit_message_text_by_bot(bot: Bot, event_loop):
# message by bot
async with FakeTelegram(message_data=EDITED_MESSAGE, loop=event_loop):
result = await bot.edit_message_text(text=msg.text, chat_id=msg.chat.id, message_id=msg.message_id)
- assert result == msg
+ if result != msg:
+ raise AssertionError
async def test_edit_message_text_by_user(bot: Bot, event_loop):
@@ -531,8 +595,10 @@ async def test_edit_message_text_by_user(bot: Bot, event_loop):
# message by user
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.edit_message_text(text=msg.text, chat_id=msg.chat.id, message_id=msg.message_id)
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_set_sticker_set_thumb(bot: Bot, event_loop):
@@ -540,11 +606,14 @@ async def test_set_sticker_set_thumb(bot: Bot, event_loop):
async with FakeTelegram(message_data=True, loop=event_loop):
result = await bot.set_sticker_set_thumb(name='test', user_id=123456789, thumb='file_id')
- assert isinstance(result, bool)
- assert result is True
+ if not isinstance(result, bool):
+ raise AssertionError
+ if result is not True:
+ raise AssertionError
async def test_bot_id(bot: Bot):
""" Check getting id from token. """
bot = Bot(TOKEN)
- assert bot.id == BOT_ID # BOT_ID is a correct id from TOKEN
+ if bot.id != BOT_ID:
+ raise AssertionError
diff --git a/tests/test_bot/test_api.py b/tests/test_bot/test_api.py
index 29418169..9b494154 100644
--- a/tests/test_bot/test_api.py
+++ b/tests/test_bot/test_api.py
@@ -25,7 +25,8 @@ def invalid_token_fixture(request):
class TestCheckToken:
def test_valid(self):
- assert check_token(VALID_TOKEN) is True
+ if check_token(VALID_TOKEN) is not True:
+ raise AssertionError
def test_invalid_token(self, invalid_token):
with pytest.raises(ValidationError):
diff --git a/tests/test_bot/test_session.py b/tests/test_bot/test_session.py
index 5458e3c8..9115daa3 100644
--- a/tests/test_bot/test_session.py
+++ b/tests/test_bot/test_session.py
@@ -16,16 +16,24 @@ class TestAiohttpSession:
async def test_create_bot(self):
bot = BaseBot(token="42:correct")
- assert bot._session is None
- assert isinstance(bot._connector_init, dict)
- assert all(key in {"limit", "ssl", "loop"} for key in bot._connector_init)
- assert isinstance(bot._connector_class, type)
- assert issubclass(bot._connector_class, aiohttp.TCPConnector)
+ if bot._session is not None:
+ raise AssertionError
+ if not isinstance(bot._connector_init, dict):
+ raise AssertionError
+ if not all(key in {"limit", "ssl", "loop"} for key in bot._connector_init):
+ raise AssertionError
+ if not isinstance(bot._connector_class, type):
+ raise AssertionError
+ if not issubclass(bot._connector_class, aiohttp.TCPConnector):
+ raise AssertionError
- assert bot._session is None
+ if bot._session is not None:
+ raise AssertionError
- assert isinstance(bot.session, aiohttp.ClientSession)
- assert bot.session == bot._session
+ if not isinstance(bot.session, aiohttp.ClientSession):
+ raise AssertionError
+ if bot.session != bot._session:
+ raise AssertionError
@pytest.mark.asyncio
async def test_create_proxy_bot(self):
@@ -39,15 +47,21 @@ class TestAiohttpSession:
proxy_auth=aiohttp.BasicAuth(username, password, "encoding"),
)
- assert bot._connector_class == aiohttp_socks.SocksConnector
+ if bot._connector_class != aiohttp_socks.SocksConnector:
+ raise AssertionError
- assert isinstance(bot._connector_init, dict)
+ if not isinstance(bot._connector_init, dict):
+ raise AssertionError
init_kwargs = bot._connector_init
- assert init_kwargs["username"] == username
- assert init_kwargs["password"] == password
- assert init_kwargs["host"] == host
- assert init_kwargs["port"] == port
+ if init_kwargs["username"] != username:
+ raise AssertionError
+ if init_kwargs["password"] != password:
+ raise AssertionError
+ if init_kwargs["host"] != host:
+ raise AssertionError
+ if init_kwargs["port"] != port:
+ raise AssertionError
@pytest.mark.asyncio
async def test_close_session(self):
@@ -59,4 +73,5 @@ class TestAiohttpSession:
mocked_close.assert_called_once()
await aiohttp_client_0.close()
- assert aiohttp_client_0 != bot.session # will create new session
+ if aiohttp_client_0 == bot.session:
+ raise AssertionError
diff --git a/tests/test_dispatcher.py b/tests/test_dispatcher.py
index 700bda2d..9e146220 100644
--- a/tests/test_dispatcher.py
+++ b/tests/test_dispatcher.py
@@ -23,7 +23,8 @@ class TestDispatcherInit:
:type bot: Bot
"""
dp = Dispatcher(bot=bot)
- assert isinstance(dp, Dispatcher)
+ if not isinstance(dp, Dispatcher):
+ raise AssertionError
@pytest.mark.parametrize("bot_instance", [None, Bot, 123, 'abc'])
async def test_wrong_bot_instance(self, bot_instance):
diff --git a/tests/test_dispatcher/test_filters/test_builtin.py b/tests/test_dispatcher/test_filters/test_builtin.py
index edfc9291..88b3f754 100644
--- a/tests/test_dispatcher/test_filters/test_builtin.py
+++ b/tests/test_dispatcher/test_filters/test_builtin.py
@@ -23,7 +23,8 @@ class TestText:
value = 'spam and eggs'
config = {param: value}
res = Text.validate(config)
- assert res == {key: value}
+ if res != {key: value}:
+ raise AssertionError
@pytest.mark.parametrize(
@@ -70,7 +71,8 @@ class TestText:
),
)
def test_extract_chat_ids(chat_id: ChatIDArgumentType, expected: Set[int]):
- assert extract_chat_ids(chat_id) == expected
+ if extract_chat_ids(chat_id) != expected:
+ raise AssertionError
class TestForwardedMessageFilter:
@@ -84,7 +86,8 @@ class TestForwardedMessageFilter:
not_forwarded_message = Message(**MESSAGE)
assert await filter.check(forwarded_message)
- assert not await filter.check(not_forwarded_message)
+ if await filter.check(not_forwarded_message):
+ raise AssertionError
@pytest.mark.asyncio
async def test_filter_not_forwarded_messages(self):
@@ -95,7 +98,8 @@ class TestForwardedMessageFilter:
not_forwarded_message = Message(**MESSAGE)
assert await filter.check(not_forwarded_message)
- assert not await filter.check(forwarded_message)
+ if await filter.check(forwarded_message):
+ raise AssertionError
class TestIDFilter:
diff --git a/tests/test_dispatcher/test_filters/test_state.py b/tests/test_dispatcher/test_filters/test_state.py
index f7ca6d12..78bebe01 100644
--- a/tests/test_dispatcher/test_filters/test_state.py
+++ b/tests/test_dispatcher/test_filters/test_state.py
@@ -16,4 +16,5 @@ class TestStatesGroup:
inner2 = InnerState2
form_childs = Form.all_childs
- assert form_childs == (InnerState1, InnerState2)
+ if form_childs != (InnerState1, InnerState2):
+ raise AssertionError
diff --git a/tests/test_dispatcher/test_handler.py b/tests/test_dispatcher/test_handler.py
index b823c8f8..993176af 100644
--- a/tests/test_dispatcher/test_handler.py
+++ b/tests/test_dispatcher/test_handler.py
@@ -38,10 +38,14 @@ class TestHandlerObj:
obj1 = Handler.HandlerObj(callback1, _get_spec(callback1))
obj2 = Handler.HandlerObj(callback2, _get_spec(callback2))
- assert set(obj1.spec.args) == {"foo", "bar", "baz"}
- assert obj1.handler == callback1
- assert set(obj2.spec.args) == {"foo", "bar", "baz"}
- assert obj2.handler == callback2
+ if set(obj1.spec.args) != {"foo", "bar", "baz"}:
+ raise AssertionError
+ if obj1.handler != callback1:
+ raise AssertionError
+ if set(obj2.spec.args) != {"foo", "bar", "baz"}:
+ raise AssertionError
+ if obj2.handler != callback2:
+ raise AssertionError
@pytest.mark.parametrize(
"callback,kwargs,result",
@@ -63,4 +67,5 @@ class TestHandlerObj:
)
def test__check_spec(self, callback, kwargs, result):
spec = _get_spec(callback)
- assert _check_spec(spec, kwargs) == result
+ if _check_spec(spec, kwargs) != result:
+ raise AssertionError
diff --git a/tests/test_filters.py b/tests/test_filters.py
index 90693529..940b166e 100644
--- a/tests/test_filters.py
+++ b/tests/test_filters.py
@@ -256,7 +256,8 @@ class TestTextFilter:
else:
_test_filter_list = test_filter_list
_test_text = test_text
- assert result is (_test_text in _test_filter_list)
+ if result is not (_test_text in _test_filter_list):
+ raise AssertionError
await check(Message(text=test_text))
await check(CallbackQuery(data=test_text))
@@ -276,36 +277,43 @@ class TestCommandStart:
test_filter = CommandStart() # empty filter
message = Message(text=self.START)
result = await test_filter.check(message)
- assert result
+ if not result:
+ raise AssertionError
async def test_start_command_payload_is_matched(self):
test_filter = CommandStart(deep_link=self.GOOD)
message = Message(text=f'{self.START} {self.GOOD}')
result = await test_filter.check(message)
- assert result == {'deep_link': self.GOOD}
+ if result != {'deep_link': self.GOOD}:
+ raise AssertionError
async def test_start_command_payload_is_not_matched(self):
test_filter = CommandStart(deep_link=self.GOOD)
message = Message(text=f'{self.START} {self.BAD}')
result = await test_filter.check(message)
- assert result is False
+ if result is not False:
+ raise AssertionError
async def test_start_command_payload_pattern_is_matched(self):
test_filter = CommandStart(deep_link=self.GOOD_PATTERN)
message = Message(text=f'{self.START} {self.GOOD}')
result = await test_filter.check(message)
- assert isinstance(result, dict)
+ if not isinstance(result, dict):
+ raise AssertionError
match = result.get('deep_link')
- assert isinstance(match, Match)
+ if not isinstance(match, Match):
+ raise AssertionError
async def test_start_command_payload_pattern_is_not_matched(self):
test_filter = CommandStart(deep_link=self.BAD_PATTERN)
message = Message(text=f'{self.START} {self.GOOD}')
result = await test_filter.check(message)
- assert result is False
+ if result is not False:
+ raise AssertionError
async def test_start_command_payload_is_encoded(self):
test_filter = CommandStart(deep_link=self.GOOD, encoded=True)
message = Message(text=f'{self.START} {self.ENCODED}')
result = await test_filter.check(message)
- assert result == {'deep_link': self.GOOD}
+ if result != {'deep_link': self.GOOD}:
+ raise AssertionError
diff --git a/tests/test_states_group.py b/tests/test_states_group.py
index 47e49ce1..ebec1f64 100644
--- a/tests/test_states_group.py
+++ b/tests/test_states_group.py
@@ -26,78 +26,102 @@ alone_in_group = State('alone', group_name='home')
def test_default_state():
- assert default_state.state is None
+ if default_state.state is not None:
+ raise AssertionError
def test_any_state():
- assert any_state.state == '*'
+ if any_state.state != '*':
+ raise AssertionError
def test_alone_state():
- assert alone_state.state == '@:alone'
- assert alone_in_group.state == 'home:alone'
+ if alone_state.state != '@:alone':
+ raise AssertionError
+ if alone_in_group.state != 'home:alone':
+ raise AssertionError
def test_group_names():
- assert MyGroup.__group_name__ == 'MyGroup'
- assert MyGroup.__full_group_name__ == 'MyGroup'
+ if MyGroup.__group_name__ != 'MyGroup':
+ raise AssertionError
+ if MyGroup.__full_group_name__ != 'MyGroup':
+ raise AssertionError
- assert MyGroup.MySubGroup.__group_name__ == 'MySubGroup'
- assert MyGroup.MySubGroup.__full_group_name__ == 'MyGroup.MySubGroup'
+ if MyGroup.MySubGroup.__group_name__ != 'MySubGroup':
+ raise AssertionError
+ if MyGroup.MySubGroup.__full_group_name__ != 'MyGroup.MySubGroup':
+ raise AssertionError
- assert MyGroup.MySubGroup.NewGroup.__group_name__ == 'NewGroup'
- assert MyGroup.MySubGroup.NewGroup.__full_group_name__ == 'MyGroup.MySubGroup.NewGroup'
+ if MyGroup.MySubGroup.NewGroup.__group_name__ != 'NewGroup':
+ raise AssertionError
+ if MyGroup.MySubGroup.NewGroup.__full_group_name__ != 'MyGroup.MySubGroup.NewGroup':
+ raise AssertionError
def test_custom_group_in_group():
- assert MyGroup.MySubGroup.in_custom_group.state == 'custom_group:in_custom_group'
+ if MyGroup.MySubGroup.in_custom_group.state != 'custom_group:in_custom_group':
+ raise AssertionError
def test_custom_state_name_in_group():
- assert MyGroup.MySubGroup.NewGroup.renamed_state.state == 'MyGroup.MySubGroup.NewGroup:spam_state'
+ if MyGroup.MySubGroup.NewGroup.renamed_state.state != 'MyGroup.MySubGroup.NewGroup:spam_state':
+ raise AssertionError
def test_group_states_names():
- assert len(MyGroup.states) == 3
- assert len(MyGroup.all_states) == 9
+ if len(MyGroup.states) != 3:
+ raise AssertionError
+ if len(MyGroup.all_states) != 9:
+ raise AssertionError
- assert MyGroup.states_names == ('MyGroup:state', 'MyGroup:state_1', 'MyGroup:state_2')
- assert MyGroup.MySubGroup.states_names == (
+ if MyGroup.states_names != ('MyGroup:state', 'MyGroup:state_1', 'MyGroup:state_2'):
+ raise AssertionError
+ if MyGroup.MySubGroup.states_names != (
'MyGroup.MySubGroup:sub_state', 'MyGroup.MySubGroup:sub_state_1', 'MyGroup.MySubGroup:sub_state_2',
- 'custom_group:in_custom_group')
- assert MyGroup.MySubGroup.NewGroup.states_names == (
- 'MyGroup.MySubGroup.NewGroup:spam', 'MyGroup.MySubGroup.NewGroup:spam_state')
+ 'custom_group:in_custom_group'):
+ raise AssertionError
+ if MyGroup.MySubGroup.NewGroup.states_names != (
+ 'MyGroup.MySubGroup.NewGroup:spam', 'MyGroup.MySubGroup.NewGroup:spam_state'):
+ raise AssertionError
- assert MyGroup.all_states_names == (
+ if MyGroup.all_states_names != (
'MyGroup:state', 'MyGroup:state_1', 'MyGroup:state_2',
'MyGroup.MySubGroup:sub_state',
'MyGroup.MySubGroup:sub_state_1',
'MyGroup.MySubGroup:sub_state_2',
'custom_group:in_custom_group',
'MyGroup.MySubGroup.NewGroup:spam',
- 'MyGroup.MySubGroup.NewGroup:spam_state')
+ 'MyGroup.MySubGroup.NewGroup:spam_state'):
+ raise AssertionError
- assert MyGroup.MySubGroup.all_states_names == (
+ if MyGroup.MySubGroup.all_states_names != (
'MyGroup.MySubGroup:sub_state',
'MyGroup.MySubGroup:sub_state_1',
'MyGroup.MySubGroup:sub_state_2',
'custom_group:in_custom_group',
'MyGroup.MySubGroup.NewGroup:spam',
- 'MyGroup.MySubGroup.NewGroup:spam_state')
+ 'MyGroup.MySubGroup.NewGroup:spam_state'):
+ raise AssertionError
- assert MyGroup.MySubGroup.NewGroup.all_states_names == (
+ if MyGroup.MySubGroup.NewGroup.all_states_names != (
'MyGroup.MySubGroup.NewGroup:spam',
- 'MyGroup.MySubGroup.NewGroup:spam_state')
+ 'MyGroup.MySubGroup.NewGroup:spam_state'):
+ raise AssertionError
def test_root_element():
root = MyGroup.MySubGroup.NewGroup.spam.get_root()
- assert issubclass(root, StatesGroup)
- assert root == MyGroup
+ if not issubclass(root, StatesGroup):
+ raise AssertionError
+ if root != MyGroup:
+ raise AssertionError
- assert root == MyGroup.state.get_root()
- assert root == MyGroup.MySubGroup.get_root()
+ if root != MyGroup.state.get_root():
+ raise AssertionError
+ if root != MyGroup.MySubGroup.get_root():
+ raise AssertionError
with pytest.raises(RuntimeError):
any_state.get_root()
diff --git a/tests/test_utils/test_auth_widget.py b/tests/test_utils/test_auth_widget.py
index 0f9d3542..c8bdd394 100644
--- a/tests/test_utils/test_auth_widget.py
+++ b/tests/test_utils/test_auth_widget.py
@@ -21,7 +21,8 @@ def data():
def test_generate_hash(data):
res = generate_hash(data, TOKEN)
- assert res == data['hash']
+ if res != data['hash']:
+ raise AssertionError
class Test_check_token:
@@ -29,18 +30,22 @@ class Test_check_token:
This case gonna be deleted
"""
def test_ok(self, data):
- assert check_token(data, TOKEN) is True
+ if check_token(data, TOKEN) is not True:
+ raise AssertionError
def test_fail(self, data):
data.pop('username')
- assert check_token(data, TOKEN) is False
+ if check_token(data, TOKEN) is not False:
+ raise AssertionError
class Test_check_integrity:
def test_ok(self, data):
- assert check_integrity(TOKEN, data) is True
+ if check_integrity(TOKEN, data) is not True:
+ raise AssertionError
def test_fail(self, data):
data.pop('username')
- assert check_integrity(TOKEN, data) is False
+ if check_integrity(TOKEN, data) is not False:
+ raise AssertionError
diff --git a/tests/test_utils/test_deep_linking.py b/tests/test_utils/test_deep_linking.py
index 18ec0235..69821c70 100644
--- a/tests/test_utils/test_deep_linking.py
+++ b/tests/test_utils/test_deep_linking.py
@@ -48,7 +48,8 @@ def get_bot_user_fixture(monkeypatch):
class TestDeepLinking:
async def test_get_start_link(self, payload):
link = await get_start_link(payload)
- assert link == f'https://t.me/{dataset.USER["username"]}?start={payload}'
+ if link != f'https://t.me/{dataset.USER["username"]}?start={payload}':
+ raise AssertionError
async def test_wrong_symbols(self, wrong_payload):
with pytest.raises(ValueError):
@@ -56,13 +57,15 @@ class TestDeepLinking:
async def test_get_startgroup_link(self, payload):
link = await get_startgroup_link(payload)
- assert link == f'https://t.me/{dataset.USER["username"]}?startgroup={payload}'
+ if link != f'https://t.me/{dataset.USER["username"]}?startgroup={payload}':
+ raise AssertionError
async def test_filter_encode_and_decode(self, payload):
_payload = filter_payload(payload)
encoded = encode_payload(_payload)
decoded = decode_payload(encoded)
- assert decoded == str(payload)
+ if decoded != str(payload):
+ raise AssertionError
async def test_get_start_link_with_encoding(self, payload):
# define link
@@ -72,4 +75,5 @@ class TestDeepLinking:
payload = filter_payload(payload)
encoded_payload = encode_payload(payload)
- assert link == f'https://t.me/{dataset.USER["username"]}?start={encoded_payload}'
+ if link != f'https://t.me/{dataset.USER["username"]}?start={encoded_payload}':
+ raise AssertionError
diff --git a/tests/test_utils/test_deprecated.py b/tests/test_utils/test_deprecated.py
index e40189c1..f7178e0e 100644
--- a/tests/test_utils/test_deprecated.py
+++ b/tests/test_utils/test_deprecated.py
@@ -4,11 +4,13 @@ from aiogram.utils.deprecated import DeprecatedReadOnlyClassVar
def test_DeprecatedReadOnlyClassVarCD():
- assert DeprecatedReadOnlyClassVar.__slots__ == ("_new_value_getter", "_warning_message")
+ if DeprecatedReadOnlyClassVar.__slots__ != ("_new_value_getter", "_warning_message"):
+ raise AssertionError
new_value_of_deprecated_cls_cd = "mpa"
deprecated_cd = DeprecatedReadOnlyClassVar("mopekaa", lambda owner: new_value_of_deprecated_cls_cd)
with pytest.warns(DeprecationWarning):
pseudo_owner_cls = type("OpekaCla$$", (), {})
- assert deprecated_cd.__get__(None, pseudo_owner_cls) == new_value_of_deprecated_cls_cd
+ if deprecated_cd.__get__(None, pseudo_owner_cls) != new_value_of_deprecated_cls_cd:
+ raise AssertionError
diff --git a/tests/test_utils/test_helper.py b/tests/test_utils/test_helper.py
index f90dacf1..4950dd7e 100644
--- a/tests/test_utils/test_helper.py
+++ b/tests/test_utils/test_helper.py
@@ -10,7 +10,8 @@ class TestOrderedHelper:
C = Item()
B = Item()
- assert Helper.all() == ['A', 'D', 'C', 'B']
+ if Helper.all() != ['A', 'D', 'C', 'B']:
+ raise AssertionError
def test_list_items_are_ordered(self):
class Helper(OrderedHelper):
@@ -19,4 +20,5 @@ class TestOrderedHelper:
C = ListItem()
B = ListItem()
- assert Helper.all() == ['A', 'D', 'C', 'B']
+ if Helper.all() != ['A', 'D', 'C', 'B']:
+ raise AssertionError
diff --git a/tests/test_utils/test_markdown.py b/tests/test_utils/test_markdown.py
index 02faea2a..2a006dd1 100644
--- a/tests/test_utils/test_markdown.py
+++ b/tests/test_utils/test_markdown.py
@@ -5,7 +5,9 @@ from aiogram.utils import markdown
class TestMarkdownEscape:
def test_equality_sign_is_escaped(self):
- assert markdown.escape_md(r"e = mc2") == r"e \= mc2"
+ if markdown.escape_md(r"e = mc2") != r"e \= mc2":
+ raise AssertionError
def test_pre_escaped(self):
- assert markdown.escape_md(r"hello\.") == r"hello\\\."
+ if markdown.escape_md(r"hello\.") != r"hello\\\.":
+ raise AssertionError
diff --git a/tests/test_utils/test_text_decorations.py b/tests/test_utils/test_text_decorations.py
index cc724dd7..2ebf77c5 100644
--- a/tests/test_utils/test_text_decorations.py
+++ b/tests/test_utils/test_text_decorations.py
@@ -4,22 +4,24 @@ from aiogram.utils import text_decorations
class TestTextDecorations:
def test_unparse_entities_normal_text(self):
- assert text_decorations.markdown_decoration.unparse(
+ if text_decorations.markdown_decoration.unparse(
"hi i'm bold and italic and still bold",
entities=[
MessageEntity(offset=3, length=34, type=MessageEntityType.BOLD),
MessageEntity(offset=12, length=10, type=MessageEntityType.ITALIC),
]
- ) == "hi *i'm bold _\rand italic_\r and still bold*"
+ ) != "hi *i'm bold _\rand italic_\r and still bold*":
+ raise AssertionError
def test_unparse_entities_emoji_text(self):
"""
emoji is encoded as two chars in json
"""
- assert text_decorations.markdown_decoration.unparse(
+ if text_decorations.markdown_decoration.unparse(
"🚀 i'm bold and italic and still bold",
entities=[
MessageEntity(offset=3, length=34, type=MessageEntityType.BOLD),
MessageEntity(offset=12, length=10, type=MessageEntityType.ITALIC),
]
- ) == "🚀 *i'm bold _\rand italic_\r and still bold*"
+ ) != "🚀 *i'm bold _\rand italic_\r and still bold*":
+ raise AssertionError
diff --git a/tests/types/test_animation.py b/tests/types/test_animation.py
index 29adeab4..3e8a075d 100644
--- a/tests/types/test_animation.py
+++ b/tests/types/test_animation.py
@@ -7,34 +7,49 @@ animation = types.Animation(**ANIMATION)
def test_export():
exported = animation.to_python()
- assert isinstance(exported, dict)
- assert exported == ANIMATION
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != ANIMATION:
+ raise AssertionError
def test_file_name():
- assert isinstance(animation.file_name, str)
- assert animation.file_name == ANIMATION['file_name']
+ if not isinstance(animation.file_name, str):
+ raise AssertionError
+ if animation.file_name != ANIMATION['file_name']:
+ raise AssertionError
def test_mime_type():
- assert isinstance(animation.mime_type, str)
- assert animation.mime_type == ANIMATION['mime_type']
+ if not isinstance(animation.mime_type, str):
+ raise AssertionError
+ if animation.mime_type != ANIMATION['mime_type']:
+ raise AssertionError
def test_file_id():
- assert isinstance(animation.file_id, str)
+ if not isinstance(animation.file_id, str):
+ raise AssertionError
# assert hash(animation) == ANIMATION['file_id']
- assert animation.file_id == ANIMATION['file_id']
+ if animation.file_id != ANIMATION['file_id']:
+ raise AssertionError
def test_file_size():
- assert isinstance(animation.file_size, int)
- assert animation.file_size == ANIMATION['file_size']
+ if not isinstance(animation.file_size, int):
+ raise AssertionError
+ if animation.file_size != ANIMATION['file_size']:
+ raise AssertionError
def test_thumb():
- assert isinstance(animation.thumb, types.PhotoSize)
- assert animation.thumb.file_id == ANIMATION['thumb']['file_id']
- assert animation.thumb.width == ANIMATION['thumb']['width']
- assert animation.thumb.height == ANIMATION['thumb']['height']
- assert animation.thumb.file_size == ANIMATION['thumb']['file_size']
+ if not isinstance(animation.thumb, types.PhotoSize):
+ raise AssertionError
+ if animation.thumb.file_id != ANIMATION['thumb']['file_id']:
+ raise AssertionError
+ if animation.thumb.width != ANIMATION['thumb']['width']:
+ raise AssertionError
+ if animation.thumb.height != ANIMATION['thumb']['height']:
+ raise AssertionError
+ if animation.thumb.file_size != ANIMATION['thumb']['file_size']:
+ raise AssertionError
diff --git a/tests/types/test_chat.py b/tests/types/test_chat.py
index a8b50764..a01447b6 100644
--- a/tests/types/test_chat.py
+++ b/tests/types/test_chat.py
@@ -7,56 +7,87 @@ chat = types.Chat(**CHAT)
def test_export():
exported = chat.to_python()
- assert isinstance(exported, dict)
- assert exported == CHAT
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != CHAT:
+ raise AssertionError
def test_id():
- assert isinstance(chat.id, int)
- assert chat.id == CHAT['id']
+ if not isinstance(chat.id, int):
+ raise AssertionError
+ if chat.id != CHAT['id']:
+ raise AssertionError
# assert hash(chat) == CHAT['id']
def test_name():
- assert isinstance(chat.first_name, str)
- assert chat.first_name == CHAT['first_name']
+ if not isinstance(chat.first_name, str):
+ raise AssertionError
+ if chat.first_name != CHAT['first_name']:
+ raise AssertionError
- assert isinstance(chat.last_name, str)
- assert chat.last_name == CHAT['last_name']
+ if not isinstance(chat.last_name, str):
+ raise AssertionError
+ if chat.last_name != CHAT['last_name']:
+ raise AssertionError
- assert isinstance(chat.username, str)
- assert chat.username == CHAT['username']
+ if not isinstance(chat.username, str):
+ raise AssertionError
+ if chat.username != CHAT['username']:
+ raise AssertionError
def test_type():
- assert isinstance(chat.type, str)
- assert chat.type == CHAT['type']
+ if not isinstance(chat.type, str):
+ raise AssertionError
+ if chat.type != CHAT['type']:
+ raise AssertionError
def test_chat_types():
- assert types.ChatType.PRIVATE == 'private'
- assert types.ChatType.GROUP == 'group'
- assert types.ChatType.SUPER_GROUP == 'supergroup'
- assert types.ChatType.CHANNEL == 'channel'
+ if types.ChatType.PRIVATE != 'private':
+ raise AssertionError
+ if types.ChatType.GROUP != 'group':
+ raise AssertionError
+ if types.ChatType.SUPER_GROUP != 'supergroup':
+ raise AssertionError
+ if types.ChatType.CHANNEL != 'channel':
+ raise AssertionError
def test_chat_type_filters():
from . import test_message
- assert types.ChatType.is_private(test_message.message)
- assert not types.ChatType.is_group(test_message.message)
- assert not types.ChatType.is_super_group(test_message.message)
- assert not types.ChatType.is_group_or_super_group(test_message.message)
- assert not types.ChatType.is_channel(test_message.message)
+ if not types.ChatType.is_private(test_message.message):
+ raise AssertionError
+ if types.ChatType.is_group(test_message.message):
+ raise AssertionError
+ if types.ChatType.is_super_group(test_message.message):
+ raise AssertionError
+ if types.ChatType.is_group_or_super_group(test_message.message):
+ raise AssertionError
+ if types.ChatType.is_channel(test_message.message):
+ raise AssertionError
def test_chat_actions():
- assert types.ChatActions.TYPING == 'typing'
- assert types.ChatActions.UPLOAD_PHOTO == 'upload_photo'
- assert types.ChatActions.RECORD_VIDEO == 'record_video'
- assert types.ChatActions.UPLOAD_VIDEO == 'upload_video'
- assert types.ChatActions.RECORD_AUDIO == 'record_audio'
- assert types.ChatActions.UPLOAD_AUDIO == 'upload_audio'
- assert types.ChatActions.UPLOAD_DOCUMENT == 'upload_document'
- assert types.ChatActions.FIND_LOCATION == 'find_location'
- assert types.ChatActions.RECORD_VIDEO_NOTE == 'record_video_note'
- assert types.ChatActions.UPLOAD_VIDEO_NOTE == 'upload_video_note'
+ if types.ChatActions.TYPING != 'typing':
+ raise AssertionError
+ if types.ChatActions.UPLOAD_PHOTO != 'upload_photo':
+ raise AssertionError
+ if types.ChatActions.RECORD_VIDEO != 'record_video':
+ raise AssertionError
+ if types.ChatActions.UPLOAD_VIDEO != 'upload_video':
+ raise AssertionError
+ if types.ChatActions.RECORD_AUDIO != 'record_audio':
+ raise AssertionError
+ if types.ChatActions.UPLOAD_AUDIO != 'upload_audio':
+ raise AssertionError
+ if types.ChatActions.UPLOAD_DOCUMENT != 'upload_document':
+ raise AssertionError
+ if types.ChatActions.FIND_LOCATION != 'find_location':
+ raise AssertionError
+ if types.ChatActions.RECORD_VIDEO_NOTE != 'record_video_note':
+ raise AssertionError
+ if types.ChatActions.UPLOAD_VIDEO_NOTE != 'upload_video_note':
+ raise AssertionError
diff --git a/tests/types/test_chat_member.py b/tests/types/test_chat_member.py
index 8e8d2cfe..d8cbac10 100644
--- a/tests/types/test_chat_member.py
+++ b/tests/types/test_chat_member.py
@@ -7,72 +7,111 @@ chat_member = types.ChatMember(**CHAT_MEMBER)
def test_export():
exported = chat_member.to_python()
- assert isinstance(exported, dict)
- assert exported == CHAT_MEMBER
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != CHAT_MEMBER:
+ raise AssertionError
def test_user():
- assert isinstance(chat_member.user, types.User)
+ if not isinstance(chat_member.user, types.User):
+ raise AssertionError
def test_status():
- assert isinstance(chat_member.status, str)
- assert chat_member.status == CHAT_MEMBER['status']
+ if not isinstance(chat_member.status, str):
+ raise AssertionError
+ if chat_member.status != CHAT_MEMBER['status']:
+ raise AssertionError
def test_privileges():
- assert isinstance(chat_member.can_be_edited, bool)
- assert chat_member.can_be_edited == CHAT_MEMBER['can_be_edited']
+ if not isinstance(chat_member.can_be_edited, bool):
+ raise AssertionError
+ if chat_member.can_be_edited != CHAT_MEMBER['can_be_edited']:
+ raise AssertionError
- assert isinstance(chat_member.can_change_info, bool)
- assert chat_member.can_change_info == CHAT_MEMBER['can_change_info']
+ if not isinstance(chat_member.can_change_info, bool):
+ raise AssertionError
+ if chat_member.can_change_info != CHAT_MEMBER['can_change_info']:
+ raise AssertionError
- assert isinstance(chat_member.can_delete_messages, bool)
- assert chat_member.can_delete_messages == CHAT_MEMBER['can_delete_messages']
+ if not isinstance(chat_member.can_delete_messages, bool):
+ raise AssertionError
+ if chat_member.can_delete_messages != CHAT_MEMBER['can_delete_messages']:
+ raise AssertionError
- assert isinstance(chat_member.can_invite_users, bool)
- assert chat_member.can_invite_users == CHAT_MEMBER['can_invite_users']
+ if not isinstance(chat_member.can_invite_users, bool):
+ raise AssertionError
+ if chat_member.can_invite_users != CHAT_MEMBER['can_invite_users']:
+ raise AssertionError
- assert isinstance(chat_member.can_restrict_members, bool)
- assert chat_member.can_restrict_members == CHAT_MEMBER['can_restrict_members']
+ if not isinstance(chat_member.can_restrict_members, bool):
+ raise AssertionError
+ if chat_member.can_restrict_members != CHAT_MEMBER['can_restrict_members']:
+ raise AssertionError
- assert isinstance(chat_member.can_pin_messages, bool)
- assert chat_member.can_pin_messages == CHAT_MEMBER['can_pin_messages']
+ if not isinstance(chat_member.can_pin_messages, bool):
+ raise AssertionError
+ if chat_member.can_pin_messages != CHAT_MEMBER['can_pin_messages']:
+ raise AssertionError
- assert isinstance(chat_member.can_promote_members, bool)
- assert chat_member.can_promote_members == CHAT_MEMBER['can_promote_members']
+ if not isinstance(chat_member.can_promote_members, bool):
+ raise AssertionError
+ if chat_member.can_promote_members != CHAT_MEMBER['can_promote_members']:
+ raise AssertionError
def test_int():
- assert int(chat_member) == chat_member.user.id
- assert isinstance(int(chat_member), int)
+ if int(chat_member) != chat_member.user.id:
+ raise AssertionError
+ if not isinstance(int(chat_member), int):
+ raise AssertionError
def test_chat_member_status():
- assert types.ChatMemberStatus.CREATOR == 'creator'
- assert types.ChatMemberStatus.ADMINISTRATOR == 'administrator'
- assert types.ChatMemberStatus.MEMBER == 'member'
- assert types.ChatMemberStatus.RESTRICTED == 'restricted'
- assert types.ChatMemberStatus.LEFT == 'left'
- assert types.ChatMemberStatus.KICKED == 'kicked'
+ if types.ChatMemberStatus.CREATOR != 'creator':
+ raise AssertionError
+ if types.ChatMemberStatus.ADMINISTRATOR != 'administrator':
+ raise AssertionError
+ if types.ChatMemberStatus.MEMBER != 'member':
+ raise AssertionError
+ if types.ChatMemberStatus.RESTRICTED != 'restricted':
+ raise AssertionError
+ if types.ChatMemberStatus.LEFT != 'left':
+ raise AssertionError
+ if types.ChatMemberStatus.KICKED != 'kicked':
+ raise AssertionError
def test_chat_member_status_filters():
- assert types.ChatMemberStatus.is_chat_admin(chat_member.status)
- assert types.ChatMemberStatus.is_chat_member(chat_member.status)
+ if not types.ChatMemberStatus.is_chat_admin(chat_member.status):
+ raise AssertionError
+ if not types.ChatMemberStatus.is_chat_member(chat_member.status):
+ raise AssertionError
- assert types.ChatMemberStatus.is_chat_admin(types.ChatMemberStatus.CREATOR)
- assert types.ChatMemberStatus.is_chat_admin(types.ChatMemberStatus.ADMINISTRATOR)
+ if not types.ChatMemberStatus.is_chat_admin(types.ChatMemberStatus.CREATOR):
+ raise AssertionError
+ if not types.ChatMemberStatus.is_chat_admin(types.ChatMemberStatus.ADMINISTRATOR):
+ raise AssertionError
- assert types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.CREATOR)
- assert types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.ADMINISTRATOR)
- assert types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.MEMBER)
- assert types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.RESTRICTED)
+ if not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.CREATOR):
+ raise AssertionError
+ if not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.ADMINISTRATOR):
+ raise AssertionError
+ if not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.MEMBER):
+ raise AssertionError
+ if not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.RESTRICTED):
+ raise AssertionError
- assert not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.LEFT)
- assert not types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.KICKED)
+ if types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.LEFT):
+ raise AssertionError
+ if types.ChatMemberStatus.is_chat_member(types.ChatMemberStatus.KICKED):
+ raise AssertionError
def test_chat_member_filters():
- assert chat_member.is_chat_admin()
- assert chat_member.is_chat_member()
+ if not chat_member.is_chat_admin():
+ raise AssertionError
+ if not chat_member.is_chat_member():
+ raise AssertionError
diff --git a/tests/types/test_document.py b/tests/types/test_document.py
index eb353ae6..4a76975a 100644
--- a/tests/types/test_document.py
+++ b/tests/types/test_document.py
@@ -7,30 +7,41 @@ document = types.Document(**DOCUMENT)
def test_export():
exported = document.to_python()
- assert isinstance(exported, dict)
- assert exported == DOCUMENT
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != DOCUMENT:
+ raise AssertionError
def test_file_name():
- assert isinstance(document.file_name, str)
- assert document.file_name == DOCUMENT['file_name']
+ if not isinstance(document.file_name, str):
+ raise AssertionError
+ if document.file_name != DOCUMENT['file_name']:
+ raise AssertionError
def test_mime_type():
- assert isinstance(document.mime_type, str)
- assert document.mime_type == DOCUMENT['mime_type']
+ if not isinstance(document.mime_type, str):
+ raise AssertionError
+ if document.mime_type != DOCUMENT['mime_type']:
+ raise AssertionError
def test_file_id():
- assert isinstance(document.file_id, str)
+ if not isinstance(document.file_id, str):
+ raise AssertionError
# assert hash(document) == DOCUMENT['file_id']
- assert document.file_id == DOCUMENT['file_id']
+ if document.file_id != DOCUMENT['file_id']:
+ raise AssertionError
def test_file_size():
- assert isinstance(document.file_size, int)
- assert document.file_size == DOCUMENT['file_size']
+ if not isinstance(document.file_size, int):
+ raise AssertionError
+ if document.file_size != DOCUMENT['file_size']:
+ raise AssertionError
def test_thumb():
- assert document.thumb is None
+ if document.thumb is not None:
+ raise AssertionError
diff --git a/tests/types/test_game.py b/tests/types/test_game.py
index 8350d858..484cc258 100644
--- a/tests/types/test_game.py
+++ b/tests/types/test_game.py
@@ -7,25 +7,35 @@ game = types.Game(**GAME)
def test_export():
exported = game.to_python()
- assert isinstance(exported, dict)
- assert exported == GAME
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != GAME:
+ raise AssertionError
def test_title():
- assert isinstance(game.title, str)
- assert game.title == GAME['title']
+ if not isinstance(game.title, str):
+ raise AssertionError
+ if game.title != GAME['title']:
+ raise AssertionError
def test_description():
- assert isinstance(game.description, str)
- assert game.description == GAME['description']
+ if not isinstance(game.description, str):
+ raise AssertionError
+ if game.description != GAME['description']:
+ raise AssertionError
def test_photo():
- assert isinstance(game.photo, list)
- assert len(game.photo) == len(GAME['photo'])
- assert all(map(lambda t: isinstance(t, types.PhotoSize), game.photo))
+ if not isinstance(game.photo, list):
+ raise AssertionError
+ if len(game.photo) != len(GAME['photo']):
+ raise AssertionError
+ if not all(map(lambda t: isinstance(t, types.PhotoSize), game.photo)):
+ raise AssertionError
def test_animation():
- assert isinstance(game.animation, types.Animation)
+ if not isinstance(game.animation, types.Animation):
+ raise AssertionError
diff --git a/tests/types/test_input_media.py b/tests/types/test_input_media.py
index f867e1f6..ca250a9e 100644
--- a/tests/types/test_input_media.py
+++ b/tests/types/test_input_media.py
@@ -21,21 +21,31 @@ def test_field_width():
"""
https://core.telegram.org/bots/api#inputmedia
"""
- assert not hasattr(input_media_audio, WIDTH)
- assert not hasattr(input_media_document, WIDTH)
- assert not hasattr(input_media_photo, WIDTH)
+ if hasattr(input_media_audio, WIDTH):
+ raise AssertionError
+ if hasattr(input_media_document, WIDTH):
+ raise AssertionError
+ if hasattr(input_media_photo, WIDTH):
+ raise AssertionError
- assert hasattr(input_media_animation, WIDTH)
- assert hasattr(input_media_video, WIDTH)
+ if not hasattr(input_media_animation, WIDTH):
+ raise AssertionError
+ if not hasattr(input_media_video, WIDTH):
+ raise AssertionError
def test_field_height():
"""
https://core.telegram.org/bots/api#inputmedia
"""
- assert not hasattr(input_media_audio, HEIGHT)
- assert not hasattr(input_media_document, HEIGHT)
- assert not hasattr(input_media_photo, HEIGHT)
+ if hasattr(input_media_audio, HEIGHT):
+ raise AssertionError
+ if hasattr(input_media_document, HEIGHT):
+ raise AssertionError
+ if hasattr(input_media_photo, HEIGHT):
+ raise AssertionError
- assert hasattr(input_media_animation, HEIGHT)
- assert hasattr(input_media_video, HEIGHT)
+ if not hasattr(input_media_animation, HEIGHT):
+ raise AssertionError
+ if not hasattr(input_media_video, HEIGHT):
+ raise AssertionError
diff --git a/tests/types/test_message.py b/tests/types/test_message.py
index d68650ac..a668c204 100644
--- a/tests/types/test_message.py
+++ b/tests/types/test_message.py
@@ -9,32 +9,45 @@ message = types.Message(**MESSAGE)
def test_export():
exported_chat = message.to_python()
- assert isinstance(exported_chat, dict)
- assert exported_chat == MESSAGE
+ if not isinstance(exported_chat, dict):
+ raise AssertionError
+ if exported_chat != MESSAGE:
+ raise AssertionError
def test_message_id():
# assert hash(message) == MESSAGE['message_id']
- assert message.message_id == MESSAGE['message_id']
- assert message['message_id'] == MESSAGE['message_id']
+ if message.message_id != MESSAGE['message_id']:
+ raise AssertionError
+ if message['message_id'] != MESSAGE['message_id']:
+ raise AssertionError
def test_from():
- assert isinstance(message.from_user, types.User)
- assert message.from_user == message['from']
+ if not isinstance(message.from_user, types.User):
+ raise AssertionError
+ if message.from_user != message['from']:
+ raise AssertionError
def test_chat():
- assert isinstance(message.chat, types.Chat)
- assert message.chat == message['chat']
+ if not isinstance(message.chat, types.Chat):
+ raise AssertionError
+ if message.chat != message['chat']:
+ raise AssertionError
def test_date():
- assert isinstance(message.date, datetime.datetime)
- assert int(message.date.timestamp()) == MESSAGE['date']
- assert message.date == message['date']
+ if not isinstance(message.date, datetime.datetime):
+ raise AssertionError
+ if int(message.date.timestamp()) != MESSAGE['date']:
+ raise AssertionError
+ if message.date != message['date']:
+ raise AssertionError
def test_text():
- assert message.text == MESSAGE['text']
- assert message['text'] == MESSAGE['text']
+ if message.text != MESSAGE['text']:
+ raise AssertionError
+ if message['text'] != MESSAGE['text']:
+ raise AssertionError
diff --git a/tests/types/test_photo.py b/tests/types/test_photo.py
index d81a13a4..f2ed4915 100644
--- a/tests/types/test_photo.py
+++ b/tests/types/test_photo.py
@@ -7,22 +7,32 @@ photo = types.PhotoSize(**PHOTO)
def test_export():
exported = photo.to_python()
- assert isinstance(exported, dict)
- assert exported == PHOTO
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != PHOTO:
+ raise AssertionError
def test_file_id():
- assert isinstance(photo.file_id, str)
- assert photo.file_id == PHOTO['file_id']
+ if not isinstance(photo.file_id, str):
+ raise AssertionError
+ if photo.file_id != PHOTO['file_id']:
+ raise AssertionError
def test_file_size():
- assert isinstance(photo.file_size, int)
- assert photo.file_size == PHOTO['file_size']
+ if not isinstance(photo.file_size, int):
+ raise AssertionError
+ if photo.file_size != PHOTO['file_size']:
+ raise AssertionError
def test_size():
- assert isinstance(photo.width, int)
- assert isinstance(photo.height, int)
- assert photo.width == PHOTO['width']
- assert photo.height == PHOTO['height']
+ if not isinstance(photo.width, int):
+ raise AssertionError
+ if not isinstance(photo.height, int):
+ raise AssertionError
+ if photo.width != PHOTO['width']:
+ raise AssertionError
+ if photo.height != PHOTO['height']:
+ raise AssertionError
diff --git a/tests/types/test_reply_keyboard.py b/tests/types/test_reply_keyboard.py
index ee6da29c..385f5fd1 100644
--- a/tests/types/test_reply_keyboard.py
+++ b/tests/types/test_reply_keyboard.py
@@ -6,8 +6,10 @@ reply_keyboard = types.ReplyKeyboardMarkup(**REPLY_KEYBOARD_MARKUP)
def test_serialize():
- assert reply_keyboard.to_python() == REPLY_KEYBOARD_MARKUP
+ if reply_keyboard.to_python() != REPLY_KEYBOARD_MARKUP:
+ raise AssertionError
def test_deserialize():
- assert reply_keyboard.to_object(reply_keyboard.to_python()) == reply_keyboard
+ if reply_keyboard.to_object(reply_keyboard.to_python()) != reply_keyboard:
+ raise AssertionError
diff --git a/tests/types/test_update.py b/tests/types/test_update.py
index 6309c315..d82d45fa 100644
--- a/tests/types/test_update.py
+++ b/tests/types/test_update.py
@@ -7,15 +7,20 @@ update = types.Update(**UPDATE)
def test_export():
exported = update.to_python()
- assert isinstance(exported, dict)
- assert exported == UPDATE
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != UPDATE:
+ raise AssertionError
def test_update_id():
- assert isinstance(update.update_id, int)
+ if not isinstance(update.update_id, int):
+ raise AssertionError
# assert hash(update) == UPDATE['update_id']
- assert update.update_id == UPDATE['update_id']
+ if update.update_id != UPDATE['update_id']:
+ raise AssertionError
def test_message():
- assert isinstance(update.message, types.Message)
+ if not isinstance(update.message, types.Message):
+ raise AssertionError
diff --git a/tests/types/test_user.py b/tests/types/test_user.py
index 24b76f58..c1ca2f88 100644
--- a/tests/types/test_user.py
+++ b/tests/types/test_user.py
@@ -9,41 +9,57 @@ user = types.User(**USER)
def test_export():
exported = user.to_python()
- assert isinstance(exported, dict)
- assert exported == USER
+ if not isinstance(exported, dict):
+ raise AssertionError
+ if exported != USER:
+ raise AssertionError
def test_id():
- assert isinstance(user.id, int)
- assert user.id == USER['id']
+ if not isinstance(user.id, int):
+ raise AssertionError
+ if user.id != USER['id']:
+ raise AssertionError
# assert hash(user) == USER['id']
def test_bot():
- assert isinstance(user.is_bot, bool)
- assert user.is_bot == USER['is_bot']
+ if not isinstance(user.is_bot, bool):
+ raise AssertionError
+ if user.is_bot != USER['is_bot']:
+ raise AssertionError
def test_name():
- assert user.first_name == USER['first_name']
- assert user.last_name == USER['last_name']
- assert user.username == USER['username']
+ if user.first_name != USER['first_name']:
+ raise AssertionError
+ if user.last_name != USER['last_name']:
+ raise AssertionError
+ if user.username != USER['username']:
+ raise AssertionError
def test_language_code():
- assert user.language_code == USER['language_code']
- assert user.locale == Locale.parse(USER['language_code'], sep='-')
+ if user.language_code != USER['language_code']:
+ raise AssertionError
+ if user.locale != Locale.parse(USER['language_code'], sep='-'):
+ raise AssertionError
def test_full_name():
- assert user.full_name == f"{USER['first_name']} {USER['last_name']}"
+ if user.full_name != f"{USER['first_name']} {USER['last_name']}":
+ raise AssertionError
def test_mention():
- assert user.mention == f"@{USER['username']}"
- assert user.get_mention('foo', as_html=False) == f"[foo](tg://user?id={USER['id']})"
- assert user.get_mention('foo', as_html=True) == f"foo"
+ if user.mention != f"@{USER['username']}":
+ raise AssertionError
+ if user.get_mention('foo', as_html=False) != f"[foo](tg://user?id={USER['id']})":
+ raise AssertionError
+ if user.get_mention('foo', as_html=True) != f"foo":
+ raise AssertionError
def test_url():
- assert user.url == f"tg://user?id={USER['id']}"
+ if user.url != f"tg://user?id={USER['id']}":
+ raise AssertionError