def test_webhook_no_ssl(self):
print("Testing Webhook without SSL")
bot = MockBot("", messages=0)
self.updater.bot = bot
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook("127.0.0.1", port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(), GroupChat(1, "Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding="utf-8")
except TypeError:
payload = bytes(update.to_json())
header = {"content-type": "application/json", "content-length": str(len(payload))}
r = Request("http://127.0.0.1:%d/" % port, data=payload, headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, "Webhook Test 2")
def test_webhook(self):
print('Testing Webhook')
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook('127.0.0.1',
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py')
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding='utf-8')
except TypeError:
payload = bytes(update.to_json())
header = {
'content-type': 'application/json',
'content-length': str(len(payload))
}
r = Request('http://127.0.0.1:%d/TOKEN' % port,
data=payload,
headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
request = Request('http://localhost:%d/webookhandler.py' % port)
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
request.get_method = lambda: 'HEAD'
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook(self):
print('Testing Webhook')
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook('127.0.0.1', port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py')
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding='utf-8')
except TypeError:
payload = bytes(update.to_json())
header = {
'content-type': 'application/json',
'content-length': str(len(payload))
}
r = Request('http://127.0.0.1:%d/TOKEN' % port,
data=payload,
headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
request = Request('http://localhost:%d/webookhandler.py' % port)
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
request.get_method = lambda: 'HEAD'
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook(self):
print("Testing Webhook")
bot = MockBot("", messages=0)
self.updater.bot = bot
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook(
"127.0.0.1", port, url_path="TOKEN", cert="./tests/test_updater.py", key="./tests/test_updater.py"
)
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(), GroupChat(1, "Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding="utf-8")
except TypeError:
payload = bytes(update.to_json())
header = {"content-type": "application/json", "content-length": str(len(payload))}
r = Request("http://127.0.0.1:%d/TOKEN" % port, data=payload, headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, "Webhook Test")
print("Test other webhook server functionalities...")
request = Request("http://localhost:%d/webookhandler.py" % port)
response = urlopen(request)
self.assertEqual(b"", response.read())
self.assertEqual(200, response.code)
request.get_method = lambda: "HEAD"
response = urlopen(request)
self.assertEqual(b"", response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook_default_quote(self, monkeypatch, updater):
updater._default_quote = True
q = Queue()
monkeypatch.setattr(updater.bot, 'set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr(updater.bot, 'delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
updater.start_webhook(ip, port, url_path='TOKEN')
sleep(.2)
# Now, we send an update to the server via urlopen
update = Update(1,
message=Message(1,
User(1, '', False),
None,
Chat(1, ''),
text='Webhook'))
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(.2)
# assert q.get(False) == update
assert q.get(False).message.default_quote is True
updater.stop()
def error_handler(self, update: Update, context: CallbackContext):
logger.error(f'Update:\n{update}')
logger.exception(context.error)
# send detailed report to developer
traceback_str = ''.join(
traceback.format_tb(context.error.__traceback__))
user_info_str = self.get_user_info_str(update.effective_user)
# convert TelegramObject to json, load it to dict
# and then dump back to json with pretty indents
update_json = json.dumps(json.loads(update.to_json()), indent=2)
message = (f'#error\n\n'
f'user:\n{user_info_str}\n\n'
f'error:\n`{context.error}`\n\n')
error_fn = f'error_{datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")}.txt'
with open(error_fn, 'w') as fout:
fout.write(f'user:\n{user_info_str}\n\n')
fout.write(f'error:\n{context.error}\n\n')
fout.write(f'traceback:\n{traceback_str}\n\n')
fout.write(f'update:\n{update_json}')
with open(error_fn, 'rb') as fin:
context.bot.send_document(self.contact_chat_id,
document=fin,
caption=message,
parse_mode=ParseMode.MARKDOWN)
def test_webhook_no_ssl(self, monkeypatch, updater):
q = Queue()
monkeypatch.setattr(updater.bot, 'set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr(updater.bot, 'delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
updater.start_webhook(ip, port, webhook_url=None)
sleep(0.2)
# Now, we send an update to the server via urlopen
update = Update(
1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Webhook 2'),
)
self._send_webhook_msg(ip, port, update.to_json())
sleep(0.2)
assert q.get(False) == update
updater.stop()
def test_webhook_ssl_just_for_telegram(self, monkeypatch, updater):
q = Queue()
def set_webhook(**kwargs):
self.test_flag.append(bool(kwargs.get('certificate')))
return True
orig_wh_server_init = WebhookServer.__init__
def webhook_server_init(*args):
self.test_flag = [args[-1] is None]
orig_wh_server_init(*args)
monkeypatch.setattr(updater.bot, 'set_webhook', set_webhook)
monkeypatch.setattr(updater.bot, 'delete_webhook', lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update', lambda _, u: q.put(u))
monkeypatch.setattr(
'telegram.ext.utils.webhookhandler.WebhookServer.__init__', webhook_server_init
)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
updater.start_webhook(ip, port, webhook_url=None, cert='./tests/test_updater.py')
sleep(0.2)
# Now, we send an update to the server via urlopen
update = Update(
1,
message=Message(1, None, Chat(1, ''), from_user=User(1, '', False), text='Webhook 2'),
)
self._send_webhook_msg(ip, port, update.to_json())
sleep(0.2)
assert q.get(False) == update
updater.stop()
assert self.test_flag == [True, True]
def test_webhook_arbitrary_callback_data(self, monkeypatch, updater,
invalid_data):
"""Here we only test one simple setup. telegram.ext.ExtBot.insert_callback_data is tested
extensively in test_bot.py in conjunction with get_updates."""
updater.bot.arbitrary_callback_data = True
try:
q = Queue()
monkeypatch.setattr(updater.bot, 'set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr(updater.bot, 'delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
updater.start_webhook(ip, port, url_path='TOKEN')
sleep(0.2)
try:
# Now, we send an update to the server via urlopen
reply_markup = InlineKeyboardMarkup.from_button(
InlineKeyboardButton(text='text',
callback_data='callback_data'))
if not invalid_data:
reply_markup = updater.bot.callback_data_cache.process_keyboard(
reply_markup)
message = Message(
1,
None,
None,
reply_markup=reply_markup,
)
update = Update(1, message=message)
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(0.2)
received_update = q.get(False)
assert received_update == update
button = received_update.message.reply_markup.inline_keyboard[
0][0]
if invalid_data:
assert isinstance(button.callback_data,
InvalidCallbackData)
else:
assert button.callback_data == 'callback_data'
# Test multiple shutdown() calls
updater.httpd.shutdown()
finally:
updater.httpd.shutdown()
sleep(0.2)
assert not updater.httpd.is_running
updater.stop()
finally:
updater.bot.arbitrary_callback_data = False
updater.bot.callback_data_cache.clear_callback_data()
updater.bot.callback_data_cache.clear_callback_queries()
def test_webhook(self, monkeypatch, updater, ext_bot):
# Testing with both ExtBot and Bot to make sure any logic in WebhookHandler
# that depends on this distinction works
if ext_bot and not isinstance(updater.bot, ExtBot):
updater.bot = ExtBot(updater.bot.token)
if not ext_bot and not type(updater.bot) is Bot:
updater.bot = Bot(updater.bot.token)
q = Queue()
monkeypatch.setattr(updater.bot, 'set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr(updater.bot, 'delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
updater.start_webhook(ip, port, url_path='TOKEN')
sleep(0.2)
try:
# Now, we send an update to the server via urlopen
update = Update(
1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Webhook'),
)
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(0.2)
assert q.get(False) == update
# Returns 404 if path is incorrect
with pytest.raises(HTTPError) as excinfo:
self._send_webhook_msg(ip, port, None, 'webookhandler.py')
assert excinfo.value.code == 404
with pytest.raises(HTTPError) as excinfo:
self._send_webhook_msg(ip,
port,
None,
'webookhandler.py',
get_method=lambda: 'HEAD')
assert excinfo.value.code == 404
# Test multiple shutdown() calls
updater.httpd.shutdown()
finally:
updater.httpd.shutdown()
sleep(0.2)
assert not updater.httpd.is_running
updater.stop()
def test_webhook(self, monkeypatch, updater):
q = Queue()
monkeypatch.setattr('telegram.Bot.set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.Bot.delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
updater.start_webhook(
ip,
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py',
)
sleep(.2)
# SSL-Wrapping will fail, so we start the server without SSL
thr = Thread(target=updater.httpd.serve_forever)
thr.start()
try:
# Now, we send an update to the server via urlopen
update = Update(1,
message=Message(1,
User(1, '', False),
None,
Chat(1, ''),
text='Webhook'))
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(.2)
assert q.get(False) == update
response = self._send_webhook_msg(ip, port, None,
'webookhandler.py')
assert b'' == response.read()
assert 200 == response.code
response = self._send_webhook_msg(ip,
port,
None,
'webookhandler.py',
get_method=lambda: 'HEAD')
assert b'' == response.read()
assert 200 == response.code
# Test multiple shutdown() calls
updater.httpd.shutdown()
finally:
updater.httpd.shutdown()
thr.join()
def handle_callback_query(self, update: telegram.Update,
context: telegram.ext.CallbackContext):
Logger.info(update.to_json())
callback_data = CallbackData.from_str(update.callback_query.data)
if Ombi.process_callback_data(callback_data):
Logger.info(
f"Callback was processed correctly: {callback_data.__dict__}")
context.bot.delete_message(
chat_id=int(update.callback_query.message.chat.id),
message_id=int(update.callback_query.message.message_id),
)
else:
Logger.error("Callback could not be processed correctly")
def test_webhook(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
handler = MessageHandler([], self.telegramHandlerTest)
d.addHandler(handler)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip,
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py',
webhook_url=None)
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1,
User(1, "Tester"),
datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
response = self._send_webhook_msg(
ip, port,
None, 'webookhandler.py',
get_method=lambda: 'HEAD')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
handler = MessageHandler([], self.telegramHandlerTest)
d.addHandler(handler)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip,
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py',
webhook_url=None)
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1,
User(1, "Tester"),
datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
response = self._send_webhook_msg(
ip, port,
None, 'webookhandler.py',
get_method=lambda: 'HEAD')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook_no_ssl(self):
print('Testing Webhook without SSL')
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook('127.0.0.1', port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding='utf-8')
except TypeError:
payload = bytes(update.to_json())
header = {
'content-type': 'application/json',
'content-length': str(len(payload))
}
r = Request('http://127.0.0.1:%d/' % port,
data=payload,
headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def test_webhook_no_ssl(self):
print('Testing Webhook without SSL')
bot = MockBot('', messages=0)
self.updater.bot = bot
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook('127.0.0.1', port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding='utf-8')
except TypeError:
payload = bytes(update.to_json())
header = {
'content-type': 'application/json',
'content-length': str(len(payload))
}
r = Request('http://127.0.0.1:%d/' % port,
data=payload,
headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def test_webhook_no_ssl(self, monkeypatch, updater):
q = Queue()
monkeypatch.setattr('telegram.Bot.set_webhook', lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.Bot.delete_webhook', lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update', lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
updater.start_webhook(ip, port, webhook_url=None)
sleep(.2)
# Now, we send an update to the server via urlopen
update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''), text='Webhook 2'))
self._send_webhook_msg(ip, port, update.to_json())
sleep(.2)
assert q.get(False) == update
def test_webhook(self, monkeypatch, updater):
q = Queue()
monkeypatch.setattr('telegram.Bot.set_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.Bot.delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
updater.start_webhook(ip, port, url_path='TOKEN')
sleep(.2)
try:
# Now, we send an update to the server via urlopen
update = Update(1,
message=Message(1,
User(1, '', False),
None,
Chat(1, ''),
text='Webhook'))
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(.2)
assert q.get(False) == update
# Returns 404 if path is incorrect
try:
self._send_webhook_msg(ip, port, None, 'webookhandler.py')
except HTTPError as httperr:
assert httperr.code == 404
try:
self._send_webhook_msg(ip,
port,
None,
'webookhandler.py',
get_method=lambda: 'HEAD')
except HTTPError as httperr:
assert httperr.code == 404
# Test multiple shutdown() calls
updater.httpd.shutdown()
finally:
updater.httpd.shutdown()
sleep(.2)
assert not updater.httpd.is_running
updater.stop()
def test_webhook_max_connections(self, monkeypatch, updater,
pass_max_connections):
q = Queue()
max_connections = 42
def set_webhook(**kwargs):
print(kwargs)
self.test_flag = kwargs.get('max_connections') == (
max_connections if pass_max_connections else 40)
return True
monkeypatch.setattr(updater.bot, 'set_webhook', set_webhook)
monkeypatch.setattr(updater.bot, 'delete_webhook',
lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update',
lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port
if pass_max_connections:
updater.start_webhook(ip,
port,
webhook_url=None,
max_connections=max_connections)
else:
updater.start_webhook(ip, port, webhook_url=None)
sleep(0.2)
# Now, we send an update to the server via urlopen
update = Update(
1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Webhook 2'),
)
self._send_webhook_msg(ip, port, update.to_json())
sleep(0.2)
assert q.get(False) == update
updater.stop()
assert self.test_flag is True
def test_webhook(self, monkeypatch, updater):
q = Queue()
monkeypatch.setattr('telegram.Bot.set_webhook', lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.Bot.delete_webhook', lambda *args, **kwargs: True)
monkeypatch.setattr('telegram.ext.Dispatcher.process_update', lambda _, u: q.put(u))
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
updater.start_webhook(
ip,
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py', )
sleep(.2)
# SSL-Wrapping will fail, so we start the server without SSL
thr = Thread(target=updater.httpd.serve_forever)
thr.start()
try:
# Now, we send an update to the server via urlopen
update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''),
text='Webhook'))
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(.2)
assert q.get(False) == update
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py')
assert b'' == response.read()
assert 200 == response.code
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py',
get_method=lambda: 'HEAD')
assert b'' == response.read()
assert 200 == response.code
# Test multiple shutdown() calls
updater.httpd.shutdown()
finally:
updater.httpd.shutdown()
thr.join()
def test_webhook_no_ssl(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip, port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json())
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def test_webhook_no_ssl(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip, port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json())
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def continue_posting(update: Update, started_post: dict, user: User):
if update.callback_query:
if update.callback_query.data == "nope":
# cancel posting
cached_post_delete(update.effective_user.id)
return "Ок, забыли 👌"
elif update.callback_query.data in {"post", "link", "question"}:
# ask for title
started_post["type"] = update.callback_query.data
cached_post_set(update.effective_user.id, started_post)
return f"Отлично. Теперь надо придумать заголовок, чтобы всем было понятно о чем это. " \
f"Подумайте и пришлите его следующим сообщением 👇"
elif update.callback_query.data == "go":
# go-go-go, post the post
FormClass = POST_TYPE_MAP.get(started_post["type"]) or PostTextForm
form = FormClass(started_post)
if not form.is_valid():
return f"🤦♂️ Что-то пошло не так. Пришлите нам багрепорт. " \
f"Вот ошибка:\n```{str(form.errors)}```"
if Post.check_duplicate(user=user,
title=form.cleaned_data["title"]):
return "🤔 Выглядит как дубликат вашего прошлого поста. " \
"Проверьте всё ли в порядке и пришлите ниже другой заголовок 👇"
is_ok = Post.check_rate_limits(user)
if not is_ok:
return "🙅♂️ Извините, вы сегодня запостили слишком много постов. Попробуйте попозже"
post = form.save(commit=False)
post.author = user
post.type = started_post["type"]
post.meta = {"telegram": update.to_json()}
post.save()
post_url = settings.APP_HOST + reverse("show_post",
kwargs={
"post_type": post.type,
"post_slug": post.slug
})
cached_post_delete(update.effective_user.id)
return f"Запостили 🚀🚀🚀\n\n{post_url}"
if update.message:
started_post["title"] = str(update.message.text
or update.message.caption
or "").strip()[:128]
if len(started_post["title"]) < 7:
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"Какой-то короткий заголовок. Пришлите другой, подлинее",
reply_markup=telegram.InlineKeyboardMarkup([[
telegram.InlineKeyboardButton("❌ Отменить всё",
callback_data=f"nope"),
]]))
return
cached_post_set(update.effective_user.id, started_post)
emoji = Post.TYPE_TO_EMOJI.get(started_post["type"]) or "🔥"
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"Заголовок принят. Теперь пост выглядит как-то так:\n\n"
f"{emoji} <b>{started_post['title']}</b>\n\n"
f"{started_post['text'] or ''}\n\n"
f"{started_post['url'] or ''}\n\n"
f"<b>Будем постить?</b> (после публикации его можно будет подредактировать на сайте)",
reply_markup=telegram.InlineKeyboardMarkup([
[
telegram.InlineKeyboardButton("✅ Поехали",
callback_data=f"go"),
telegram.InlineKeyboardButton("❌ Отмена",
callback_data=f"nope"),
],
]))
