async def animation(bot, chat_id): with data_file("game.gif").open("rb") as f: thumb = data_file("thumb.jpg") return (await bot.send_animation(chat_id, animation=f, read_timeout=50, thumb=thumb.open("rb"))).animation
def test_from_input_input_media(self): input_media_no_thumb = InputMediaPhoto( media=data_file("telegram.jpg").read_bytes()) input_media_thumb = InputMediaVideo( media=data_file("telegram.mp4").read_bytes(), thumb=data_file("telegram.jpg").read_bytes(), ) request_parameter = RequestParameter.from_input( "key", input_media_no_thumb) expected_no_thumb = input_media_no_thumb.to_dict() expected_no_thumb.update( {"media": input_media_no_thumb.media.attach_uri}) assert request_parameter.value == expected_no_thumb assert request_parameter.input_files == [input_media_no_thumb.media] request_parameter = RequestParameter.from_input( "key", input_media_thumb) expected_thumb = input_media_thumb.to_dict() expected_thumb.update({"media": input_media_thumb.media.attach_uri}) expected_thumb.update({"thumb": input_media_thumb.thumb.attach_uri}) assert request_parameter.value == expected_thumb assert request_parameter.input_files == [ input_media_thumb.media, input_media_thumb.thumb ] request_parameter = RequestParameter.from_input( "key", [input_media_thumb, input_media_no_thumb]) assert request_parameter.value == [expected_thumb, expected_no_thumb] assert request_parameter.input_files == [ input_media_thumb.media, input_media_thumb.thumb, input_media_no_thumb.media, ]
def test_with_local_files(self): input_media_animation = InputMediaAnimation( data_file("telegram.mp4"), thumb=data_file("telegram.jpg")) assert input_media_animation.media == data_file( "telegram.mp4").as_uri() assert input_media_animation.thumb == data_file( "telegram.jpg").as_uri()
def test_mimetypes(self, caplog): # Only test a few to make sure logic works okay assert InputFile( data_file("telegram.jpg").open("rb")).mimetype == "image/jpeg" # For some reason python can guess the type on macOS assert InputFile(data_file("telegram.webp").open("rb")).mimetype in [ "application/octet-stream", "image/webp", ] assert InputFile( data_file("telegram.mp3").open("rb")).mimetype == "audio/mpeg" # For some reason windows drops the trailing i assert InputFile(data_file("telegram.midi").open("rb")).mimetype in [ "audio/mid", "audio/midi", ] # Test guess from file assert InputFile(BytesIO(b"blah"), filename="tg.jpg").mimetype == "image/jpeg" assert InputFile(BytesIO(b"blah"), filename="tg.mp3").mimetype == "audio/mpeg" # Test fallback assert (InputFile( BytesIO(b"blah"), filename="tg.notaproperext").mimetype == "application/octet-stream" ) assert InputFile( BytesIO(b"blah")).mimetype == "application/octet-stream" # Test string file assert InputFile( data_file("text_file.txt").open()).mimetype == "text/plain"
async def test_max_caption_length(self, bot, chat_id): good_caption = "a" * constants.MessageLimit.CAPTION_LENGTH with data_file("telegram.png").open("rb") as f: good_msg = await bot.send_photo(photo=f, caption=good_caption, chat_id=chat_id) assert good_msg.caption == good_caption bad_caption = good_caption + "Z" match = "Media_caption_too_long" with pytest.raises(BadRequest, match=match), data_file("telegram.png").open("rb") as f: await bot.send_photo(photo=f, caption=bad_caption, chat_id=chat_id)
def test_from_input_inputmedia_without_attach(self): """This case will never happen, but we test it for completeness""" input_media = InputMediaVideo( data_file("telegram.png").read_bytes(), thumb=data_file("telegram.png").read_bytes(), parse_mode=None, ) input_media.media.attach_name = None input_media.thumb.attach_name = None request_parameter = RequestParameter.from_input("key", input_media) assert request_parameter.value == {"type": "video"} assert request_parameter.input_files == [ input_media.media, input_media.thumb ]
def test_parse_file_input_attach(self, attach): source_file = data_file("text_file.txt") parsed = telegram._utils.files.parse_file_input( source_file.read_bytes(), attach=attach) assert isinstance(parsed, InputFile) assert bool(parsed.attach_name) is attach
async def test_create_new_sticker_set_local_files(self, monkeypatch, bot, chat_id): # For just test that the correct paths are passed as we have no local bot API set up test_flag = False file = data_file("telegram.jpg") expected = file.as_uri() async def make_assertion(_, data, *args, **kwargs): nonlocal test_flag test_flag = (data.get("png_sticker") == expected and data.get("tgs_sticker") == expected and data.get("webm_sticker") == expected) monkeypatch.setattr(bot, "_post", make_assertion) await bot.create_new_sticker_set( chat_id, "name", "title", "emoji", png_sticker=file, tgs_sticker=file, webm_sticker=file, ) assert test_flag monkeypatch.delattr(bot, "_post")
async def test_bot_methods_1_webm(self, bot, chat_id): with data_file("telegram_video_sticker.webm").open("rb") as f: assert await bot.add_sticker_to_set( chat_id, f"video_test_by_{bot.username}", webm_sticker=f, emojis="🤔")
async def test_bot_methods_1_tgs(self, bot, chat_id): assert await bot.add_sticker_to_set( chat_id, f"animated_test_by_{bot.username}", tgs_sticker=data_file("telegram_animated_sticker.tgs").open("rb"), emojis="😄", )
def local_file(bot): return File( TestFile.file_id, TestFile.file_unique_id, file_path=str(data_file("local_file.txt")), file_size=TestFile.file_size, bot=bot, )
async def func(): return await bot.send_media_group( chat_id, [ InputMediaVideo(video_file), InputMediaPhoto(photo_file), InputMediaPhoto(data_file("telegram.jpg").read_bytes()), ], )
async def test_send_string(self, bot, chat_id): # We test this here and not at the respective test modules because it's not worth # duplicating the test for the different methods message = await bot.send_document( chat_id, InputFile(data_file("text_file.txt").read_text(encoding="utf-8"))) out = BytesIO() assert await (await message.document.get_file()).download(out=out) out.seek(0) assert out.read().decode("utf-8") == "PTB Rocks! ⅞"
def test_parse_file_input_bytes(self): source_file = data_file("text_file.txt") parsed = telegram._utils.files.parse_file_input( source_file.read_bytes()) assert isinstance(parsed, InputFile) assert parsed.filename == "application.octet-stream" parsed = telegram._utils.files.parse_file_input( source_file.read_bytes(), filename="test_file") assert isinstance(parsed, InputFile) assert parsed.filename == "test_file"
async def test_send_video_local_files(self, monkeypatch, bot, chat_id): # For just test that the correct paths are passed as we have no local bot API set up test_flag = False file = data_file("telegram.jpg") expected = file.as_uri() async def make_assertion(_, data, *args, **kwargs): nonlocal test_flag test_flag = data.get("video") == expected and data.get("thumb") == expected monkeypatch.setattr(bot, "_post", make_assertion) await bot.send_video(chat_id, file, thumb=file) assert test_flag
def test_parse_file_input_file_like(self): source_file = data_file("game.gif") with source_file.open("rb") as file: parsed = telegram._utils.files.parse_file_input(file) assert isinstance(parsed, InputFile) assert parsed.filename == "game.gif" with source_file.open("rb") as file: parsed = telegram._utils.files.parse_file_input( file, filename="test_file") assert isinstance(parsed, InputFile) assert parsed.filename == "test_file"
async def test_upload_sticker_file_local_files(self, monkeypatch, bot, chat_id): # For just test that the correct paths are passed as we have no local bot API set up test_flag = False file = data_file("telegram.jpg") expected = file.as_uri() async def make_assertion(_, data, *args, **kwargs): nonlocal test_flag test_flag = data.get("png_sticker") == expected monkeypatch.setattr(bot, "_post", make_assertion) await bot.upload_sticker_file(chat_id, file) assert test_flag monkeypatch.delattr(bot, "_post")
async def test_bot_methods_1_png(self, bot, chat_id, sticker_file): with data_file("telegram_sticker.png").open("rb") as f: # chat_id was hardcoded as 95205500 but it stopped working for some reason file = await bot.upload_sticker_file(chat_id, f) assert file assert await bot.add_sticker_to_set(chat_id, f"test_by_{bot.username}", png_sticker=file.file_id, emojis="😄") # Also test with file input and mask assert await bot.add_sticker_to_set( chat_id, f"test_by_{bot.username}", png_sticker=sticker_file, emojis="😄", mask_position=MaskPosition(MaskPosition.EYES, -1, 1, 2), )
def input_media_photo() -> InputMediaPhoto: return InputMediaPhoto( media=data_file("telegram.jpg").read_bytes(), parse_mode=None, )
def input_media_video() -> InputMediaVideo: return InputMediaVideo( media=data_file("telegram.mp4").read_bytes(), thumb=data_file("telegram.jpg").read_bytes(), parse_mode=None, )
def test_with_local_files(self): input_media_document = InputMediaDocument( data_file("telegram.mp4"), thumb=data_file("telegram.jpg")) assert input_media_document.media == data_file("telegram.mp4").as_uri() assert input_media_document.thumb == data_file("telegram.jpg").as_uri()
def test_with_local_files(self): input_media_audio = InputMediaAudio(data_file("telegram.mp4"), thumb=data_file("telegram.jpg")) assert input_media_audio.media == data_file("telegram.mp4").as_uri() assert input_media_audio.thumb == data_file("telegram.jpg").as_uri()
def test_with_local_files(self): input_media_photo = InputMediaPhoto(data_file("telegram.mp4")) assert input_media_photo.media == data_file("telegram.mp4").as_uri()
def animation_file(): f = data_file("game.gif").open("rb") yield f f.close()
async def test_start_webhook_parameters_passing(self, updater, monkeypatch): expected_delete_webhook = dict(drop_pending_updates=None, ) expected_set_webhook = dict( certificate=None, max_connections=40, allowed_updates=None, ip_address=None, secret_token=None, **expected_delete_webhook, ) async def set_webhook(*args, **kwargs): for key, value in expected_set_webhook.items(): assert kwargs.pop(key, None) == value, f"set, {key}, {value}" assert kwargs in ( { "url": "http://127.0.0.1:80/" }, { "url": "http://listen:80/" }, { "url": "https://listen-ssl:42/ssl-path" }, ) return True async def delete_webhook(*args, **kwargs): for key, value in expected_delete_webhook.items(): assert kwargs.pop(key, None) == value, f"delete, {key}, {value}" assert kwargs == {} return True async def serve_forever(*args, **kwargs): kwargs.get("ready").set() monkeypatch.setattr(updater.bot, "set_webhook", set_webhook) monkeypatch.setattr(updater.bot, "delete_webhook", delete_webhook) monkeypatch.setattr(WebhookServer, "serve_forever", serve_forever) async with updater: await updater.start_webhook() await updater.stop() expected_delete_webhook = dict( drop_pending_updates=True, api_kwargs=None, ) expected_set_webhook = dict( certificate=data_file("sslcert.pem").read_bytes(), max_connections=47, allowed_updates=["message"], ip_address="123.456.789", secret_token=None, **expected_delete_webhook, ) await updater.start_webhook( listen="listen", allowed_updates=["message"], drop_pending_updates=True, ip_address="123.456.789", max_connections=47, cert=str(data_file("sslcert.pem").resolve()), ) await updater.stop() await updater.start_webhook( listen="listen-ssl", port=42, url_path="ssl-path", allowed_updates=["message"], drop_pending_updates=True, ip_address="123.456.789", max_connections=47, cert=data_file("sslcert.pem"), key=data_file("sslcert.key"), ) await updater.stop()
def document_file(): f = data_file("telegram.png").open("rb") yield f f.close()
def video_note_file(): f = data_file("telegram2.mp4").open("rb") yield f f.close()
async def document(bot, chat_id): with data_file("telegram.png").open("rb") as f: return (await bot.send_document(chat_id, document=f, read_timeout=50)).document
async def video_note(bot, chat_id): with data_file("telegram2.mp4").open("rb") as f: return (await bot.send_video_note(chat_id, video_note=f, read_timeout=50)).video_note
def chatphoto_file(): f = data_file("telegram.jpg").open("rb") yield f f.close()