def setUp(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users and chats
self.cg = ChatGenerator()
# And a Messagegenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot) # type: ignore
def setUp(self):
# For use within the tests we need some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users and chats
self.ug = UserGenerator()
self.cg = ChatGenerator()
# And a Messagegenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
GamesController.init()
def test_bot(self):
u = self.mg.get_message()
self.assertIsInstance(u.message.bot, Mockbot)
self.assertEqual(u.message.bot.username, "MockBot")
b = Mockbot(username="******")
mg2 = MessageGenerator(bot=b)
u = mg2.get_message()
self.assertEqual(u.message.bot.username, "AnotherBot")
with self.assertRaises(BadBotException):
mg3 = MessageGenerator(bot="Yeah!")
class TestMessageGeneratorReplies(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_reply(self):
u1 = self.mg.get_message(text="this is the first")
u2 = self.mg.get_message(
text="This is the second", reply_to_message=u1.message)
self.assertEqual(u1.message.text, u2.message.reply_to_message.text)
with self.assertRaises(BadMessageException):
u = "This is not a Messages"
self.mg.get_message(reply_to_message=u)
class TestMessageGeneratorChannelPost(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_channel_post(self):
u = self.mg.get_channel_post()
self.assertIsInstance(u, Update)
self.assertIsInstance(u.channel_post, Message)
self.assertEqual(u.channel_post.chat.type, "channel")
self.assertEqual(u.channel_post.from_user, None)
def test_with_chat(self):
cg = ChatGenerator()
group = cg.get_chat(type="group")
channel = cg.get_chat(type="channel")
u = self.mg.get_channel_post(chat=channel)
self.assertEqual(channel.title, u.channel_post.chat.title)
with self.assertRaisesRegexp(BadChatException, "telegram\.Chat"):
self.mg.get_channel_post(chat="chat")
with self.assertRaisesRegexp(BadChatException, "chat\.type"):
self.mg.get_channel_post(chat=group)
def test_with_user(self):
ug = UserGenerator()
user = ug.get_user()
u = self.mg.get_channel_post(user=user)
self.assertEqual(u.channel_post.from_user.id, user.id)
def test_with_content(self):
u = self.mg.get_channel_post(
text="this is *bold* _italic_", parse_mode="Markdown")
self.assertEqual(u.channel_post.text, "this is bold italic")
self.assertEqual(len(u.channel_post.entities), 2)
class TestClass:
bot = Mockbot()
ug = UserGenerator()
cg = ChatGenerator()
mg = MessageGenerator(bot)
pp = PicklePersistence(filename='bbqreserve_test')
updater = Updater(bot=bot, persistence=pp, use_context=True)
@pytest.mark.parametrize("test_input, expected, userdata, delme",
create_reserve_parameters)
def test_create_reservation(self, test_input, expected, userdata, delme):
user = self.ug.get_user(id=userdata['id'],
first_name=userdata['first_name'],
last_name=userdata['last_name'])
chat = self.cg.get_chat(user=user)
self.updater.dispatcher.add_handler(reserve.reserve_conv_handler)
self.updater.start_polling()
update = self.mg.get_message(user=user, chat=chat, text=test_input)
self.bot.insertUpdate(update)
sent = self.bot.sent_messages
self.updater.stop()
if delme:
import os
os.remove("bbqreserve_test")
# check expected result with actual result
assert sent[-1]['text'] == expected
def test_message(self):
mg = MessageGenerator()
message = mg.get_message().message
u = self.cqg.get_callback_query(message=message, data="test-data")
self.assertIsInstance(u, Update)
self.assertIsInstance(u.callback_query, CallbackQuery)
self.assertEqual(u.callback_query.message.message_id,
message.message_id)
u = self.cqg.get_callback_query(message=True, data="test-data")
self.assertIsInstance(u.callback_query.message, Message)
self.assertEqual(u.callback_query.message.from_user.username,
self.cqg.bot.username)
with self.assertRaises(BadMessageException):
self.cqg.get_callback_query(message="message", data="test-data")
class TestMessageGeneratorForwards(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
self.ug = UserGenerator()
self.cg = ChatGenerator()
def test_forwarded_message(self):
u1 = self.ug.get_user()
u2 = self.ug.get_user()
c = self.cg.get_chat(type="group")
u = self.mg.get_message(user=u1,
chat=c,
forward_from=u2,
text="This is a test")
self.assertEqual(u.message.from_user.id, u1.id)
self.assertEqual(u.message.forward_from.id, u2.id)
self.assertNotEqual(u.message.from_user.id, u.message.forward_from.id)
self.assertEqual(u.message.text, "This is a test")
self.assertIsInstance(u.message.forward_date, int)
import datetime
self.mg.get_message(forward_from=u2,
forward_date=datetime.datetime.now())
with self.assertRaises(BadUserException):
u3 = "This is not a User"
u = self.mg.get_message(user=u1,
chat=c,
forward_from=u3,
text="This is a test")
def test_forwarded_channel_message(self):
c = self.cg.get_chat(type="channel")
us = self.ug.get_user()
u = self.mg.get_message(text="This is a test",
forward_from=us,
forward_from_chat=c)
self.assertNotEqual(u.message.chat.id, c.id)
self.assertNotEqual(u.message.from_user.id, us.id)
self.assertEqual(u.message.forward_from.id, us.id)
self.assertEqual(u.message.text, "This is a test")
self.assertIsInstance(u.message.forward_from_message_id, int)
self.assertIsInstance(u.message.forward_date, int)
u = self.mg.get_message(text="This is a test", forward_from_chat=c)
self.assertNotEqual(u.message.from_user.id, u.message.forward_from.id)
self.assertIsInstance(u.message.forward_from, User)
self.assertIsInstance(u.message.forward_from_message_id, int)
self.assertIsInstance(u.message.forward_date, int)
with self.assertRaises(BadChatException):
c = "Not a Chat"
u = self.mg.get_message(text="This is a test", forward_from_chat=c)
with self.assertRaises(BadChatException):
c = self.cg.get_chat(type="group")
u = self.mg.get_message(text="This is a test", forward_from_chat=c)
def setUp(self):
# For use within the tests we need some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users
self.ug = UserGenerator()
# And a Messagegenerator, CallbackQueryGenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.cqg = CallbackQueryGenerator(self.bot)
self.updater = Updater(bot=self.bot)
class TestMessageGeneratorEditedMessage(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_edited_message(self):
u = self.mg.get_edited_message()
self.assertIsInstance(u.edited_message, Message)
self.assertIsInstance(u, Update)
def test_with_parameters(self):
u = self.mg.get_edited_message(
text="New *text*", parse_mode="Markdown")
self.assertEqual(u.edited_message.text, "New text")
self.assertEqual(len(u.edited_message.entities), 1)
def test_with_message(self):
m = self.mg.get_message(text="first").message
u = self.mg.get_edited_message(message=m, text="second")
self.assertEqual(m.message_id, u.edited_message.message_id)
self.assertEqual(m.chat.id, u.edited_message.chat.id)
self.assertEqual(m.from_user.id, u.edited_message.from_user.id)
self.assertEqual(u.edited_message.text, "second")
with self.assertRaises(BadMessageException):
self.mg.get_edited_message(message="Message")
def setUpClass(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
self.bot.request = telegram.utils.request.Request()
# Some generators for users and chats
self.ug = UserGenerator()
self.cg = ChatGenerator()
# And a Messagegenerator,CallbackQueryGenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.cqg = CallbackQueryGenerator(self.bot)
self.updater = Updater(bot=self.bot)
init_db("test.sqlite3")
install_commands()
add_all_handlers(self.updater.dispatcher)
with db_session:
for listable_type in Listable.__subclasses__():
for i in range(6):
listable_type(name=listable_type._discriminator_ + " " +
str(i),
url="https://url" + str(i) + ".com",
validated=True)
self.updater.start_polling()
class TestClass:
bot = Mockbot()
ug = UserGenerator()
cg = ChatGenerator()
mg = MessageGenerator(bot)
pp = PicklePersistence(filename='bbqreserve_test')
updater = Updater(bot=bot, persistence=pp, use_context=True)
@pytest.mark.parametrize("test_input, expected, userdata", cancel_reserve_parameters)
def test_cancel_reservation(self, test_input, expected, userdata):
user = self.ug.get_user(id=userdata['id'], first_name=userdata['first_name'], last_name=userdata['last_name'])
chat = self.cg.get_chat(user=user)
self.updater.dispatcher.add_handler(cancel.cancel_reserve_conv_handler)
self.updater.start_polling()
update = self.mg.get_message(user=user, chat=chat, text=test_input)
self.bot.insertUpdate(update)
sent = self.bot.sent_messages
self.updater.stop()
print(sent)
class TestMessageGeneratorEditedChannelPost(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_edited_channel_post(self):
u = self.mg.get_edited_channel_post()
self.assertIsInstance(u.edited_channel_post, Message)
self.assertIsInstance(u, Update)
def test_with_parameters(self):
u = self.mg.get_edited_channel_post(
text="New *text*", parse_mode="Markdown")
self.assertEqual(u.edited_channel_post.text, "New text")
self.assertEqual(len(u.edited_channel_post.entities), 1)
def test_with_channel_post(self):
m = self.mg.get_channel_post(text="first").channel_post
u = self.mg.get_edited_channel_post(channel_post=m, text="second")
self.assertEqual(m.message_id, u.edited_channel_post.message_id)
self.assertEqual(m.chat.id, u.edited_channel_post.chat.id)
self.assertEqual(u.edited_channel_post.text, "second")
with self.assertRaises(BadMessageException):
self.mg.get_edited_channel_post(channel_post="Message")
class TestExplore(unittest.TestCase):
def setUp(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users and chats
self.ug = UserGenerator()
self.cg = ChatGenerator()
# And a Messagegenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
def test_help(self):
# Then register the handler with he updater's dispatcher and start polling
self.updater.dispatcher.add_handler(
CommandHandler("explore", explore.explore, pass_chat_data=True))
self.updater.start_polling()
# We want to simulate a message. Since we don't care wich user sends it we let the MessageGenerator
# create random ones
update = self.mg.get_message(text="/explore")
# We insert the update with the bot so the updater can retrieve it.
self.bot.insertUpdate(update)
# sent_messages is the list with calls to the bot's outbound actions. Since we hope the message we inserted
# only triggered one sendMessage action it's length should be 1.
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.updater.stop()
def test_start(self):
def start(bot, update):
update.message.reply_text('Hi!')
self.updater.dispatcher.add_handler(CommandHandler("start", start))
self.updater.start_polling()
# Here you can see how we would handle having our own user and chat
user = self.ug.get_user(first_name="Test", last_name="The Bot")
chat = self.cg.get_chat(user=user)
update = self.mg.get_message(user=user, chat=chat, text="/start")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertEqual(sent['text'], "Hi!")
self.updater.stop()
def test_echo(self):
def echo(bot, update):
update.message.reply_text(update.message.text)
self.updater.dispatcher.add_handler(MessageHandler(Filters.text, echo))
self.updater.start_polling()
update = self.mg.get_message(text="first message")
update2 = self.mg.get_message(text="second message")
self.bot.insertUpdate(update)
self.bot.insertUpdate(update2)
self.assertEqual(len(self.bot.sent_messages), 2)
sent = self.bot.sent_messages
self.assertEqual(sent[0]['method'], "sendMessage")
self.assertEqual(sent[0]['text'], "first message")
self.assertEqual(sent[1]['text'], "second message")
self.updater.stop()
class TestMessageGeneratorStatusMessages(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
self.ug = UserGenerator()
self.cg = ChatGenerator()
def test_new_chat_member(self):
user = self.ug.get_user()
chat = self.cg.get_chat(type="group")
u = self.mg.get_message(chat=chat, new_chat_member=user)
self.assertEqual(u.message.new_chat_member.id, user.id)
with self.assertRaises(BadChatException):
self.mg.get_message(new_chat_member=user)
with self.assertRaises(BadUserException):
self.mg.get_message(chat=chat, new_chat_member="user")
def test_left_chat_member(self):
user = self.ug.get_user()
chat = self.cg.get_chat(type='group')
u = self.mg.get_message(chat=chat, left_chat_member=user)
self.assertEqual(u.message.left_chat_member.id, user.id)
with self.assertRaises(BadChatException):
self.mg.get_message(left_chat_member=user)
with self.assertRaises(BadUserException):
self.mg.get_message(chat=chat, left_chat_member="user")
def test_new_chat_title(self):
chat = self.cg.get_chat(type="group")
u = self.mg.get_message(chat=chat, new_chat_title="New title")
self.assertEqual(u.message.chat.title, "New title")
self.assertEqual(u.message.chat.title, chat.title)
with self.assertRaises(BadChatException):
self.mg.get_message(new_chat_title="New title")
def test_new_chat_photo(self):
chat = self.cg.get_chat(type="group")
u = self.mg.get_message(chat=chat, new_chat_photo=True)
self.assertIsInstance(u.message.new_chat_photo, list)
self.assertIsInstance(u.message.new_chat_photo[0], PhotoSize)
photo = [PhotoSize("2", 1, 1, file_size=3)]
u = self.mg.get_message(chat=chat, new_chat_photo=photo)
self.assertEqual(len(u.message.new_chat_photo), 1)
with self.assertRaises(BadChatException):
self.mg.get_message(new_chat_photo=True)
photo = "foto's!"
with self.assertRaises(BadMessageException):
self.mg.get_message(chat=chat, new_chat_photo=photo)
with self.assertRaises(BadMessageException):
self.mg.get_message(chat=chat, new_chat_photo=[1, 2, 3])
def test_pinned_message(self):
chat = self.cg.get_chat(type="supergroup")
message = self.mg.get_message(
chat=chat, text="this will be pinned").message
u = self.mg.get_message(chat=chat, pinned_message=message)
self.assertEqual(u.message.pinned_message.text, "this will be pinned")
with self.assertRaises(BadChatException):
self.mg.get_message(pinned_message=message)
with self.assertRaises(BadMessageException):
self.mg.get_message(chat=chat, pinned_message="message")
def test_multiple_statusmessages(self):
with self.assertRaises(BadMessageException):
self.mg.get_message(
private=False,
new_chat_member=self.ug.get_user(),
new_chat_title="New title")
class Testtimerbot(unittest.TestCase):
def setUp(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users and chats
self.cg = ChatGenerator()
# And a Messagegenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot) # type: ignore
def test_timer(self):
# first declare the callback methods
def alarm(context):
"""Function to send the alarm message"""
context.bot.sendMessage(context.job.context["chat_id"],
text='Beep!')
def set(update, context):
"""Adds a job to the queue"""
chat_id = update.message.chat_id
try:
args = context.args
# args[0] should contain the time for the timer in seconds
due = int(args[0])
if due < 0:
update.message.reply_text(
'Sorry we can not go back to the past!')
return
# Add job to queue
context.user_data["job"] = context.job_queue.run_once(
callback=alarm, when=due, context={"chat_id": chat_id})
update.message.reply_text('Timer successfully set!')
except (IndexError, ValueError):
update.message.reply_text('Usage: /set <seconds>')
def unset(update, context):
"""Removes the job if the user changed their mind"""
if 'job' not in context.user_data:
update.message.reply_text('You have no active timer')
return
job = context.user_data['job']
job.schedule_removal()
del context.user_data['job']
update.message.reply_text('Timer successfully unset!')
# Now add those handlers to the updater and start polling
dp = self.updater.dispatcher
dp.add_handler(CommandHandler("set", set))
dp.add_handler(CommandHandler("unset", unset))
self.updater.start_polling()
# we want to check if the bot returns a message to the same chat after a period of time
# so let's create a chat to use
chat = self.cg.get_chat()
# let's generate some updates we can use
u1 = self.mg.get_message(chat=chat, text="/set", parse_mode="HTML")
u2 = self.mg.get_message(chat=chat, text="/set -20", parse_mode="HTML")
u3 = self.mg.get_message(chat=chat, text="/set 6", parse_mode="HTML")
u4 = self.mg.get_message(chat=chat, text="/unset", parse_mode="HTML")
# first check some errors
self.bot.insertUpdate(u1)
self.bot.insertUpdate(u2)
self.bot.insertUpdate(u4)
data = self.bot.sent_messages
self.assertEqual(len(data), 3)
self.assertEqual(data[0]['text'], "Usage: /set <seconds>")
self.assertEqual(data[1]['text'],
'Sorry we can not go back to the past!')
self.assertEqual(data[2]['text'], 'You have no active timer')
# now check if setting and unsetting works (within timer limit)
self.bot.insertUpdate(u3)
data = self.bot.sent_messages[-1]
self.assertEqual(data['text'], 'Timer successfully set!')
time.sleep(2)
self.bot.insertUpdate(u4)
data = self.bot.sent_messages[-1]
self.assertEqual(data['text'], 'Timer successfully unset!')
# and to be certain we have to wait some more to see if it stops sending the message
# we reset the bot so we can be sure nothing more has been sent
self.bot.reset()
time.sleep(5)
data = self.bot.sent_messages
self.assertEqual(len(data), 0)
# lastly we will make sure an alarm message is sent after the timelimit has passed
self.bot.insertUpdate(u3)
time.sleep(6)
data = self.bot.sent_messages[-1]
self.assertEqual(data['text'], 'Beep!')
self.assertEqual(data['chat_id'], chat.id)
# and stop the updater.
self.updater.stop()
class TestCommands(unittest.TestCase):
def setUp(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
# Some generators for users and chats
self.ug = UserGenerator()
self.cg = ChatGenerator()
# And a Messagegenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
GamesController.init()
def test_ping(self):
# Then register the handler with he updater's dispatcher and start polling
self.updater.dispatcher.add_handler(
CommandHandler("ping", command_ping))
self.updater.start_polling()
# create with random user
update = self.mg.get_message(text="/ping")
# We insert the update with the bot so the updater can retrieve it.
self.bot.insertUpdate(update)
# sent_messages is the list with calls to the bot's outbound actions. Since we hope the message we inserted
# only triggered one sendMessage action it's length should be 1.
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertEqual(sent['text'], "pong - v0.4")
# Always stop the updater at the end of a testcase so it won't hang.
self.updater.stop()
def test_start(self):
self.updater.dispatcher.add_handler(
CommandHandler("start", command_start))
self.updater.start_polling()
update = self.mg.get_message(text="/start")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 2)
start = self.bot.sent_messages[0]
self.assertEqual(start['method'], "sendMessage")
self.assertIn("Secret Blue is a social deduction game", start['text'])
help = self.bot.sent_messages[1]
self.assertEqual(help['method'], "sendMessage")
self.assertIn("The following commands are available", help['text'])
self.updater.stop()
def test_symbols(self):
self.updater.dispatcher.add_handler(
CommandHandler("symbols", command_symbols))
self.updater.start_polling()
update = self.mg.get_message(text="/symbols")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertIn("The following symbols can appear on the board:",
sent['text'])
self.updater.stop()
def test_board_when_there_is_no_game(self):
self.updater.dispatcher.add_handler(
CommandHandler("board", command_board))
self.updater.start_polling()
update = self.mg.get_message(text="/board")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertIn(
"There is no game in this chat. Create a new game with /newgame",
sent['text'])
self.updater.stop()
def test_board_when_game_is_not_running(self):
game = Game(-999, 12345)
GamesController.games[-999] = game
self.updater.dispatcher.add_handler(
CommandHandler("board", command_board))
self.updater.start_polling()
chat = self.cg.get_chat(cid=-999)
update = self.mg.get_message(chat=chat, text="/board")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertIn(
"There is no running game in this chat. Please start the game with /startgame",
sent['text'])
self.updater.stop()
def test_board_when_game_is_running(self):
game = Game(-999, 12345)
game.board = Board(5, game)
GamesController.games[-999] = game
self.updater.dispatcher.add_handler(
CommandHandler("board", command_board))
self.updater.start_polling()
chat = self.cg.get_chat(cid=-999)
update = self.mg.get_message(chat=chat, text="/board")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertIn("--- Liberal acts ---", sent['text'])
self.updater.stop()
def setUp(self):
self.bot = Mockbot()
self.ug = UserGenerator()
self.cg = ChatGenerator()
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
class TestBot2(unittest.TestCase):
def setUp(self):
self.bot = Mockbot()
self.ug = UserGenerator()
self.cg = ChatGenerator()
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
def test_start(self):
def start(bot, update):
text = 'Привет! Введи номер теста который хочешь пройти:\n'
update.message.reply_text(text)
self.updater.dispatcher.add_handler(CommandHandler("start", start))
self.updater.start_polling()
update = self.mg.get_message(text="/start")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
self.assertEqual(sent['text'],
"Привет! Введи номер теста который хочешь пройти:\n")
self.updater.stop()
def test_create(self):
def create(bot, update):
text = 'Чтобы добавить свой текст введите его в соответствуюшем формате:\n' \
'Тест про кошек\n' \
'1)Какая ты кошка?;глотка шорсный,пушистый,лысый;3,2,1\n' \
'2)Где ты живешь?;спб,мск;1,0\n' \
'3)Любишь бегать?;да,нет;1,0\n' \
'4)Что любишь Кушать?;сосиски,молоко;2,1\n' \
'Хороший кот;5;7\n' \
'Нормальный кот;2;4\n' \
'Не кот;0;1'
update.message.reply_text(text)
self.updater.dispatcher.add_handler(CommandHandler("create", create))
self.updater.start_polling()
update = self.mg.get_message(text="/create")
self.bot.insertUpdate(update)
self.assertEqual(len(self.bot.sent_messages), 1)
sent = self.bot.sent_messages[0]
self.assertEqual(sent['method'], "sendMessage")
text = 'Чтобы добавить свой текст введите его в соответствуюшем формате:\n' \
'Тест про кошек\n' \
'1)Какая ты кошка?;глотка шорсный,пушистый,лысый;3,2,1\n' \
'2)Где ты живешь?;спб,мск;1,0\n' \
'3)Любишь бегать?;да,нет;1,0\n' \
'4)Что любишь Кушать?;сосиски,молоко;2,1\n' \
'Хороший кот;5;7\n' \
'Нормальный кот;2;4\n' \
'Не кот;0;1'
self.assertEqual(sent['text'], text)
self.updater.stop()
def test_parser(self):
@mock.patch('test_bot.parse_text',
return_value="Вы что то не так ввели")
def parser(bot, update, mock_parse_text):
if update.message.text == '/reset' or update.message.text == '/start':
return
update.message.reply_text(parse_text(update.message.text))
self.updater.dispatcher.add_handler(
MessageHandler(Filters.text, parser))
self.updater.start_polling()
update = self.mg.get_message(text="/reset")
self.bot.insertUpdate(update)
sent = self.bot.sent_messages
self.assertEqual(sent.__len__(), 0)
self.updater.stop()
self.updater.start_polling()
update = self.mg.get_message(text="NAME\n1)Question1;a,b;1,2")
self.bot.insertUpdate(update)
sent = self.bot.sent_messages
self.assertEqual(sent[0]['method'], "sendMessage")
self.assertEqual(sent[0]['text'], "Вы что то не так ввели")
self.updater.stop()
def setUp(self):
self.mg = MessageGenerator()
self.ug = UserGenerator()
self.cg = ChatGenerator()
class TestDCUBABot(unittest.TestCase):
@classmethod
def setUpClass(self):
# For use within the tests we nee some stuff. Starting with a Mockbot
self.bot = Mockbot()
self.bot.request = telegram.utils.request.Request()
# Some generators for users and chats
self.ug = UserGenerator()
self.cg = ChatGenerator()
# And a Messagegenerator,CallbackQueryGenerator and updater (for use with the bot.)
self.mg = MessageGenerator(self.bot)
self.cqg = CallbackQueryGenerator(self.bot)
self.updater = Updater(bot=self.bot)
init_db("test.sqlite3")
install_commands()
add_all_handlers(self.updater.dispatcher)
with db_session:
for listable_type in Listable.__subclasses__():
for i in range(6):
listable_type(name=listable_type._discriminator_ + " " +
str(i),
url="https://url" + str(i) + ".com",
validated=True)
self.updater.start_polling()
@classmethod
def tearDownClass(self):
self.updater.stop()
os.remove("test.sqlite3")
@classmethod
def sendCommand(self, command, chat_id=None):
user = self.ug.get_user(first_name="Test", last_name="The Bot")
if chat_id:
chat = self.cg.get_chat(chat_id)
else:
chat = self.cg.get_chat(user=user)
update = self.mg.get_message(user=user, chat=chat, text=command)
self.bot.insertUpdate(update)
return user, chat
# TODO: Cleanup this
def assert_bot_response(self,
message_text,
response_text,
chat_id=None,
random=False):
if isinstance(response_text, str):
response_text = [response_text]
sent_messages = self.bot.sent_messages
sent_messages_before = len(sent_messages)
self.sendCommand(message_text, chat_id=chat_id)
response_sent_messages = len(sent_messages) - sent_messages_before
expected_sent_messages = 0 if not response_text else\
(1 if random else len(response_text))
self.assertEqual(response_sent_messages, expected_sent_messages)
for i in range(response_sent_messages):
sent = sent_messages[sent_messages_before + i]
self.assertEqual(sent['method'], "sendMessage")
if not random:
self.assertEqual(sent['text'], response_text[i])
else:
self.assertIn(sent['text'], response_text)
def get_keyboard(self, message):
return json.loads(message['reply_markup'])['inline_keyboard']
def button_in_list(self, name, url, list_command):
self.sendCommand("/" + list_command)
inline_keyboard = self.get_keyboard(self.bot.sent_messages[-1])
for row in inline_keyboard:
for button in row:
if button["text"] == name and button["url"] == url:
return True
return False
def test_help(self):
with db_session:
for c in Command.select():
c.description = ""
Command(name="comandoSinDescripcion1")
Command(name="comandoConDescripcion1", description="Descripción 1")
Command(name="comandoSinDescripcion2")
Command(name="comandoConDescripcion2", description="Descripción 2")
Command(name="comandoSinDescripcion3")
Command(name="comandoConDescripcion3", description="Descripción 3")
self.assert_bot_response("/help",
("/comandoConDescripcion1 - Descripción 1\n"
"/comandoConDescripcion2 - Descripción 2\n"
"/comandoConDescripcion3 - Descripción 3\n"))
def test_start(self):
self.assert_bot_response(
"/start",
"Hola, ¿qué tal? ¡Mandame /help si no sabés qué puedo hacer!")
def test_estasvivo(self):
self.assert_bot_response("/estasvivo", "Sí, estoy vivo.")
def test_rozendioanalisis(self):
self.assert_bot_response("/rozendioanalisis",
"¡Sí, Rozen ya dio el final de análisis!")
# TODO: Rename
def list_test(self, command, listable_type):
self.assert_bot_response(command, "Grupos: ")
# Assertions on keyboard
inline_keyboard = self.get_keyboard(self.bot.sent_messages[-1])
self.assertEqual(len(inline_keyboard), 2) # Number of rows
for i in range(2):
row = inline_keyboard[i]
self.assertEqual((len(row)), 3) # Number of columns
for j in range(3):
button = row[j]
button_number = i * 3 + j
self.assertEqual(
button['text'],
listable_type._discriminator_ + " " + str(button_number))
self.assertEqual(button['url'],
"https://url" + str(button_number) + ".com")
self.assertEqual(button['callback_data'], button['url'])
def test_listar(self):
self.list_test("/listar", Obligatoria)
def test_listaroptativa(self):
self.list_test("/listaroptativa", Optativa)
def test_listarotro(self):
self.list_test("/listarotro", Otro)
def suggestion_test(self, command, list_command, listable_type):
name = "Sugerido"
url = "sugerido.com"
error_message = "Hiciste algo mal, la idea es que pongas:\n" +\
command + " <nombre>|<link>"
# Invalid command usages
self.assert_bot_response(command, error_message)
self.assert_bot_response(command + " " + name, error_message)
self.assert_bot_response(command + " " + name + "|", error_message)
self.assert_bot_response(command + " |" + url, error_message)
self.assert_bot_response(command + " |", error_message)
self.assert_bot_response(command + " " + name + "|" + url + "|sobra",
error_message)
# Make a group suggestion to accept
self.assert_bot_response(command + " " + name + "|" + url, [
listable_type.__name__ + ": " + name + "\n" + url,
"OK, se lo mando a Rozen."
])
# Assertions on keyboard
inline_keyboard = self.get_keyboard(self.bot.sent_messages[-2])
self.assertEqual(len(inline_keyboard), 1) # Number of rows
row = inline_keyboard[0]
self.assertEqual(len(row), 2) # Number of columns
self.assertEqual(row[0]["text"], "Aceptar")
self.assertEqual(row[1]["text"], "Rechazar")
# The suggested group shouldn't be listed
self.assertFalse(self.button_in_list(name, url, list_command))
# Pressing the "Aceptar" button makes the group listable
u = self.cqg.get_callback_query(message=self.mg.get_message().message,
data=row[0]["callback_data"])
self.bot.insertUpdate(u)
self.assertTrue(self.button_in_list(name, url, list_command))
with db_session:
delete(l for l in Listable if l.name == name)
# Make a group suggestion to reject
self.sendCommand(command + " " + name + "|" + url)
inline_keyboard = self.get_keyboard(self.bot.sent_messages[-2])
row = inline_keyboard[0]
# Pressing the "Rechazar" button doesn't make the group listable
u = self.cqg.get_callback_query(message=self.mg.get_message().message,
data=row[1]["callback_data"])
self.bot.insertUpdate(u)
self.assertFalse(self.button_in_list(name, url, list_command))
# The database is clean of rejected suggestions
with db_session:
self.assertEqual(count(l for l in Listable if l.name == name), 0)
def test_sugerirgrupo(self):
self.suggestion_test("/sugerirgrupo", "listar", Obligatoria)
def test_sugeriroptativa(self):
self.suggestion_test("/sugeriroptativa", "listaroptativa", Optativa)
def test_sugerirotro(self):
self.suggestion_test("/sugerirotro", "listarotro", Otro)
def test_logger(self):
with self.assertLogs("DCUBABOT", level='INFO') as cm:
user, _ = self.sendCommand("/listar")
first_message = 'INFO:DCUBABOT:' + str(user.id) + ': /listar'
user, _ = self.sendCommand("/estasvivo")
second_message = 'INFO:DCUBABOT:' + str(user.id) + ': /estasvivo'
self.assertEqual(cm.output, [first_message, second_message])
def test_cubawiki(self):
cubawiki_url = "https://www.cubawiki.com.ar/index.php/Segundo_Parcial_del_10/12/18"
positive_chat_id = -123456
negative_chat_id_no_cubawiki = -654321
negative_chat_id_no_entry = -123321
with db_session:
Obligatoria(name="Cubawiki",
url="test.com",
chat_id=positive_chat_id,
cubawiki_url=cubawiki_url)
Obligatoria(name="Cubawiki",
url="test.com",
chat_id=negative_chat_id_no_cubawiki)
# Positive test case
self.assert_bot_response("/cubawiki",
cubawiki_url,
chat_id=positive_chat_id)
# Negative test cases
self.assert_bot_response("/cubawiki",
None,
chat_id=negative_chat_id_no_cubawiki)
self.assert_bot_response("/cubawiki",
None,
chat_id=negative_chat_id_no_entry)
with db_session:
delete(o for o in Obligatoria if o.name == "Cubawiki")
def test_felizdia(self):
today = datetime.datetime(2019, 1, 1)
self.assertEqual(felizdia_text(today), "Feliz 1 de Enero")
today = datetime.datetime(2019, 2, 1)
self.assertEqual(felizdia_text(today), "Feliz 1 de Febrero")
today = datetime.datetime(2019, 3, 1)
self.assertEqual(felizdia_text(today), "Feliz 1 de Marzo")
today = datetime.datetime(2019, 4, 4)
self.assertEqual(felizdia_text(today), "Feliz 4 de Abril")
today = datetime.datetime(2019, 5, 21)
self.assertEqual(felizdia_text(today), "Feliz 21 de Mayo")
# TODO: Test randomness?
def test_noitip(self):
noitips = ["me siento boludeadisimo", "Not this shit again", "noitip"]
with db_session:
for phrase in noitips:
Noitip(text=phrase)
self.assert_bot_response("/noitip", noitips, random=True)
def test_asm(self):
with db_session:
AsmInstruction(mnemonic="AAD",
summary="ASCII Adjust AX Before Division",
url="https://www.felixcloutier.com/x86/aad")
AsmInstruction(mnemonic="ADD",
summary="Add",
url="https://www.felixcloutier.com/x86/add")
AsmInstruction(
mnemonic="ADDPD",
summary="Add Packed Double-Precision Floating-Point Values",
url="https://www.felixcloutier.com/x86/addpd")
AsmInstruction(mnemonic="MOV",
summary="Move to/from Control Registers",
url="http://www.felixcloutier.com/x86/MOV-1.html")
AsmInstruction(mnemonic="MOV",
summary="Move to/from Debug Registers",
url="http://www.felixcloutier.com/x86/MOV-2.html")
AsmInstruction(
mnemonic="INT n",
summary="Call to Interrupt Procedure",
url="http://www.felixcloutier.com/x86/INT%20n:INTO:INT%203.html"
)
not_found = "No pude encontrar esa instrucción."
possibles = not_found + "\nQuizás quisiste decir:"
add_info = ("[ADD] Descripción: Add.\n"
"Más info: https://www.felixcloutier.com/x86/add")
addpd_info = (
"[ADDPD] Descripción: Add Packed Double-Precision Floating-Point Values.\n"
"Más info: https://www.felixcloutier.com/x86/addpd")
mov1_info = ("[MOV] Descripción: Move to/from Control Registers.\n"
"Más info: http://www.felixcloutier.com/x86/MOV-1.html")
mov2_info = ("[MOV] Descripción: Move to/from Debug Registers.\n"
"Más info: http://www.felixcloutier.com/x86/MOV-2.html")
intn_info = (
"[INT n] Descripción: Call to Interrupt Procedure.\n"
"Más info: http://www.felixcloutier.com/x86/INT%20n:INTO:INT%203.html"
)
self.assert_bot_response("/asm", "No me pasaste ninguna instrucción.")
self.assert_bot_response("/asm add", add_info)
self.assert_bot_response("/asm ADDPD", addpd_info)
self.assert_bot_response("/asm a", not_found)
self.assert_bot_response("/asm Adp", possibles + "\n" + add_info)
self.assert_bot_response("/asm ADDPS", possibles + "\n" + addpd_info)
self.assert_bot_response(
"/asm addP", possibles + "\n" + add_info + "\n" + addpd_info)
self.assert_bot_response("/asm MOV", mov1_info + "\n" + mov2_info)
self.assert_bot_response("/asm INT n", intn_info)
class TestMessageGeneratorText(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_simple_text(self):
u = self.mg.get_message(text="This is a test")
self.assertEqual(u.message.text, "This is a test")
def test_text_with_markdown(self):
teststr = "we have *bold* `code` [google](www.google.com) @username #hashtag _italics_ ```pre block``` " \
"ftp://snt.utwente.nl /start"
u = self.mg.get_message(text=teststr)
self.assertEqual(u.message.text, teststr)
u = self.mg.get_message(text=teststr, parse_mode="Markdown")
self.assertEqual(len(u.message.entities), 9)
for ent in u.message.entities:
if ent.type == "bold":
self.assertEqual(ent.offset, 8)
self.assertEqual(ent.length, 4)
elif ent.type == "code":
self.assertEqual(ent.offset, 13)
self.assertEqual(ent.length, 4)
elif ent.type == "italic":
self.assertEqual(ent.offset, 44)
self.assertEqual(ent.length, 7)
elif ent.type == "pre":
self.assertEqual(ent.offset, 52)
self.assertEqual(ent.length, 9)
elif ent.type == "text_link":
self.assertEqual(ent.offset, 18)
self.assertEqual(ent.length, 6)
self.assertEqual(ent.url, "www.google.com")
elif ent.type == "mention":
self.assertEqual(ent.offset, 25)
self.assertEqual(ent.length, 9)
elif ent.type == "hashtag":
self.assertEqual(ent.offset, 35)
self.assertEqual(ent.length, 8)
elif ent.type == "url":
self.assertEqual(ent.offset, 62)
self.assertEqual(ent.length, 20)
elif ent.type == "bot_command":
self.assertEqual(ent.offset, 83)
self.assertEqual(ent.length, 6)
with self.assertRaises(BadMarkupException):
self.mg.get_message(
text="bad *_double_* markdown", parse_mode="Markdown")
def test_with_html(self):
teststr = "we have <b>bold</b> <code>code</code> <a href='www.google.com'>google</a> @username #hashtag " \
"<i>italics</i> <pre>pre block</pre> ftp://snt.utwente.nl /start"
u = self.mg.get_message(text=teststr)
self.assertEqual(u.message.text, teststr)
u = self.mg.get_message(text=teststr, parse_mode="HTML")
self.assertEqual(len(u.message.entities), 9)
for ent in u.message.entities:
if ent.type == "bold":
self.assertEqual(ent.offset, 8)
self.assertEqual(ent.length, 4)
elif ent.type == "code":
self.assertEqual(ent.offset, 13)
self.assertEqual(ent.length, 4)
elif ent.type == "italic":
self.assertEqual(ent.offset, 44)
self.assertEqual(ent.length, 7)
elif ent.type == "pre":
self.assertEqual(ent.offset, 52)
self.assertEqual(ent.length, 9)
elif ent.type == "text_link":
self.assertEqual(ent.offset, 18)
self.assertEqual(ent.length, 6)
self.assertEqual(ent.url, "www.google.com")
elif ent.type == "mention":
self.assertEqual(ent.offset, 25)
self.assertEqual(ent.length, 9)
elif ent.type == "hashtag":
self.assertEqual(ent.offset, 35)
self.assertEqual(ent.length, 8)
elif ent.type == "url":
self.assertEqual(ent.offset, 62)
self.assertEqual(ent.length, 20)
elif ent.type == "bot_command":
self.assertEqual(ent.offset, 83)
self.assertEqual(ent.length, 6)
with self.assertRaises(BadMarkupException):
self.mg.get_message(
text="bad <b><i>double</i></b> markup", parse_mode="HTML")
def test_wrong_markup(self):
with self.assertRaises(BadMarkupException):
self.mg.get_message(text="text", parse_mode="htmarkdownl")
class TestMessageGeneratorAttachments(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_caption_solo(self):
with self.assertRaisesRegexp(BadMessageException, r"caption without"):
self.mg.get_message(caption="my cap")
def test_more_than_one(self):
with self.assertRaisesRegexp(BadMessageException, "more than one"):
self.mg.get_message(photo=True, video=True)
def test_location(self):
loc = Location(50.012, -32.11)
u = self.mg.get_message(location=loc)
self.assertEqual(loc.longitude, u.message.location.longitude)
u = self.mg.get_message(location=True)
self.assertIsInstance(u.message.location, Location)
with self.assertRaisesRegexp(BadMessageException,
r"telegram\.Location"):
self.mg.get_message(location="location")
def test_venue(self):
ven = Venue(Location(1.0, 1.0), "some place", "somewhere")
u = self.mg.get_message(venue=ven)
self.assertEqual(u.message.venue.title, ven.title)
u = self.mg.get_message(venue=True)
self.assertIsInstance(u.message.venue, Venue)
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Venue"):
self.mg.get_message(venue="Venue")
def test_contact(self):
con = Contact("0612345", "testman")
u = self.mg.get_message(contact=con)
self.assertEqual(con.phone_number, u.message.contact.phone_number)
u = self.mg.get_message(contact=True)
self.assertIsInstance(u.message.contact, Contact)
with self.assertRaisesRegexp(BadMessageException,
r"telegram\.Contact"):
self.mg.get_message(contact="contact")
def test_voice(self):
voice = Voice("idyouknow", 12)
u = self.mg.get_message(voice=voice)
self.assertEqual(voice.file_id, u.message.voice.file_id)
cap = "voice file"
u = self.mg.get_message(voice=voice, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(voice=True)
self.assertIsInstance(u.message.voice, Voice)
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Voice"):
self.mg.get_message(voice="voice")
def test_video(self):
video = Video("idyouknow", 200, 200, 10)
u = self.mg.get_message(video=video)
self.assertEqual(video.file_id, u.message.video.file_id)
cap = "video file"
u = self.mg.get_message(video=video, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(video=True)
self.assertIsInstance(u.message.video, Video)
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Video"):
self.mg.get_message(video="video")
def test_sticker(self):
sticker = Sticker("idyouknow", 30, 30)
u = self.mg.get_message(sticker=sticker)
self.assertEqual(sticker.file_id, u.message.sticker.file_id)
cap = "sticker file"
u = self.mg.get_message(sticker=sticker, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(sticker=True)
self.assertIsInstance(u.message.sticker, Sticker)
with self.assertRaisesRegexp(BadMessageException,
r"telegram\.Sticker"):
self.mg.get_message(sticker="sticker")
def test_document(self):
document = Document("idyouknow", file_name="test.pdf")
u = self.mg.get_message(document=document)
self.assertEqual(document.file_id, u.message.document.file_id)
cap = "document file"
u = self.mg.get_message(document=document, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(document=True)
self.assertIsInstance(u.message.document, Document)
with self.assertRaisesRegexp(BadMessageException,
r"telegram\.Document"):
self.mg.get_message(document="document")
def test_audio(self):
audio = Audio("idyouknow", 23)
u = self.mg.get_message(audio=audio)
self.assertEqual(audio.file_id, u.message.audio.file_id)
cap = "audio file"
u = self.mg.get_message(audio=audio, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(audio=True)
self.assertIsInstance(u.message.audio, Audio)
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Audio"):
self.mg.get_message(audio="audio")
def test_photo(self):
photo = [PhotoSize("2", 1, 1, file_size=3)]
u = self.mg.get_message(photo=photo)
self.assertEqual(photo[0].file_size, u.message.photo[0].file_size)
cap = "photo file"
u = self.mg.get_message(photo=photo, caption=cap)
self.assertEqual(u.message.caption, cap)
u = self.mg.get_message(photo=True)
self.assertIsInstance(u.message.photo, list)
self.assertIsInstance(u.message.photo[0], PhotoSize)
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Photo"):
self.mg.get_message(photo="photo")
with self.assertRaisesRegexp(BadMessageException, r"telegram\.Photo"):
self.mg.get_message(photo=[1, 2, 3])
def setUp(self):
self.mg = MessageGenerator()
class TestMessageGeneratorCore(unittest.TestCase):
def setUp(self):
self.mg = MessageGenerator()
def test_is_update(self):
u = self.mg.get_message()
self.assertIsInstance(u, Update)
self.assertIsInstance(u.message, Message)
def test_bot(self):
u = self.mg.get_message()
self.assertIsInstance(u.message.bot, Mockbot)
self.assertEqual(u.message.bot.username, "MockBot")
b = Mockbot(username="******")
mg2 = MessageGenerator(bot=b)
u = mg2.get_message()
self.assertEqual(u.message.bot.username, "AnotherBot")
with self.assertRaises(BadBotException):
mg3 = MessageGenerator(bot="Yeah!")
def test_private_message(self):
u = self.mg.get_message(private=True)
self.assertEqual(u.message.from_user.id, u.message.chat.id)
def test_not_private(self):
u = self.mg.get_message(private=False)
self.assertEqual(u.message.chat.type, "group")
self.assertNotEqual(u.message.from_user.id, u.message.chat.id)
def test_with_user(self):
ug = UserGenerator()
us = ug.get_user()
u = self.mg.get_message(user=us, private=False)
self.assertEqual(u.message.from_user.id, us.id)
self.assertNotEqual(u.message.from_user.id, u.message.chat.id)
u = self.mg.get_message(user=us)
self.assertEqual(u.message.from_user, us)
self.assertEqual(u.message.from_user.id, u.message.chat.id)
with self.assertRaises(BadUserException):
us = "not a telegram.User"
u = self.mg.get_message(user=us)
def test_with_chat(self):
cg = ChatGenerator()
c = cg.get_chat()
u = self.mg.get_message(chat=c)
self.assertEqual(u.message.chat.id, u.message.from_user.id)
self.assertEqual(u.message.chat.id, c.id)
c = cg.get_chat(type="group")
u = self.mg.get_message(chat=c)
self.assertNotEqual(u.message.from_user.id, u.message.chat.id)
self.assertEqual(u.message.chat.id, c.id)
with self.assertRaisesRegexp(BadChatException, "get_channel_post"):
c = cg.get_chat(type="channel")
self.mg.get_message(chat=c)
with self.assertRaises(BadChatException):
c = "Not a telegram.Chat"
self.mg.get_message(chat=c)
def test_with_chat_and_user(self):
cg = ChatGenerator()
ug = UserGenerator()
us = ug.get_user()
c = cg.get_chat()
u = self.mg.get_message(user=us, chat=c)
self.assertNotEqual(u.message.from_user.id, u.message.chat.id)
self.assertEqual(u.message.from_user.id, us.id)
self.assertEqual(u.message.chat.id, c.id)
us = "not a telegram.User"
with self.assertRaises(BadUserException):
u = self.mg.get_message(user=us)
with self.assertRaises(BadUserException):
u = self.mg.get_message(chat=c, user="******")
c = "Not a telegram.Chat"
with self.assertRaises(BadChatException):
self.mg.get_message(chat=c)
with self.assertRaises(BadChatException):
self.mg.get_message(user=u, chat="chat")
def get_callback_query(self,
user=None,
chat_instance=None,
message=None,
data=None,
inline_message_id=None,
game_short_name=None):
"""
Returns a telegram.Update object containing a callback_query.
Notes:
One of message and inline_message_id must be present
One of data and game_short_name must be present
Parameters:
user (Optional[telegram.User]): User that initiated the callback_query
chat_instance (Optional[str]): unique identifier, not used
message (Optional[telegram.Message]): Message the callback_query button belongs to
inline_message_id (Optional[str]): Message the callback_query button belongs to
data (Optional[string]): Data attached to the button
game_short_name (Optional[str]): game identifier with this button
Returns:
telegram.Update: containing a :py:class:`telegram.CallbackQuery`
"""
# Required
if user:
if not isinstance(user, User):
raise BadUserException
else:
user = self.ug.get_user()
if not chat_instance:
chat_instance = self._gen_id()
if message:
if isinstance(message, Message):
pass
elif isinstance(message, bool):
chat = ChatGenerator().get_chat(user=user)
message = MessageGenerator().get_message(
user=self.bot.getMe(), chat=chat,
bot=self.bot.getMe()).message
else:
raise BadMessageException
if inline_message_id:
if isinstance(inline_message_id, str):
pass
elif isinstance(inline_message_id, bool):
inline_message_id = self._gen_id()
else:
raise BadCallbackQueryException(
"inline_message_id should be string or True")
if not len([x for x in [message, inline_message_id] if x]) == 1:
raise BadCallbackQueryException(
"exactly 1 of message and inline_message_id is needed")
if not len([x for x in [data, game_short_name] if x]) == 1:
raise BadCallbackQueryException(
"exactly 1 of data and game_short_name is needed")
return CallbackQuery(self._gen_id(), user, chat_instance, message,
data, inline_message_id, game_short_name,
self.bot)
class TestConversationbot2(unittest.TestCase):
def setUp(self):
self.bot = Mockbot()
self.cg = ChatGenerator()
self.ug = UserGenerator()
self.mg = MessageGenerator(self.bot)
self.updater = Updater(bot=self.bot)
def test_conversation(self):
CHOOSING, TYPING_REPLY, TYPING_CHOICE = range(3)
reply_keyboard = [['Age', 'Favourite colour'], ['Number of siblings', 'Something else...'], ['Done']]
markup = ReplyKeyboardMarkup(reply_keyboard, one_time_keyboard=True)
def facts_to_str(user_data):
facts = list()
for key, value in user_data.items():
facts.append('%s - %s' % (key, value))
return "\n".join(facts).join(['\n', '\n'])
def start(bot, update):
update.message.reply_text(
"Hi! My name is Doctor Botter. I will hold a more complex conversation with you. "
"Why don't you tell me something about yourself?", reply_markup=markup)
return CHOOSING
def regular_choice(bot, update, user_data):
text = update.message.text
user_data['choice'] = text
update.message.reply_text('Your %s? Yes, I would love to hear about that!' % text.lower())
return TYPING_REPLY
def custom_choice(bot, update):
update.message.reply_text('Alright, please send me the category first, '
'for example "Most impressive skill"')
return TYPING_CHOICE
def received_information(bot, update, user_data):
text = update.message.text
category = user_data['choice']
user_data[category] = text
del user_data['choice']
update.message.reply_text("Neat! Just so you know, this is what you already told me:"
"%s"
"You can tell me more, or change your opinion on something."
% facts_to_str(user_data), reply_markup=markup)
return CHOOSING
def done(bot, update, user_data):
if 'choice' in user_data:
del user_data['choice']
update.message.reply_text("I learned these facts about you:"
"%s"
"Until next time!" % facts_to_str(user_data))
user_data.clear()
return ConversationHandler.END
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
CHOOSING: [RegexHandler('^(Age|Favourite colour|Number of siblings)$',
regular_choice,
pass_user_data=True),
RegexHandler('^Something else...$',
custom_choice),
],
TYPING_CHOICE: [MessageHandler(Filters.text,
regular_choice,
pass_user_data=True),
],
TYPING_REPLY: [MessageHandler(Filters.text,
received_information,
pass_user_data=True),
],
},
fallbacks=[RegexHandler('^Done$', done, pass_user_data=True)]
)
dp = self.updater.dispatcher
dp.add_handler(conv_handler)
self.updater.start_polling()
# We are going to test a conversationhandler. Since this is tied in with user and chat we need to
# create both for consistancy
user = self.ug.get_user()
chat = self.cg.get_chat(type="group")
user2 = self.ug.get_user()
chat2 = self.cg.get_chat(user=user)
# let's start the conversation
u = self.mg.get_message(user=user, chat=chat, text="/start")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Doctor Botter\. I will")
u = self.mg.get_message(user=user, chat=chat, text="Age")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Your age\? Yes")
# now let's see what happens when another user in another chat starts conversating with the bot
u = self.mg.get_message(user=user2, chat=chat2, text="/start")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Doctor Botter\. I will")
self.assertEqual(data['chat_id'], chat2.id)
self.assertNotEqual(data['chat_id'], chat.id)
# and cancels his conv.
u = self.mg.get_message(user=user2, chat=chat2, text="Done")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Until next time!")
# cary on with first user
u = self.mg.get_message(user=user, chat=chat, text="23")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Age - 23")
u = self.mg.get_message(user=user, chat=chat, text="Something else...")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Most impressive skill")
u = self.mg.get_message(user=user, chat=chat, text="programming skill")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"Your programming skill\? Yes")
u = self.mg.get_message(user=user, chat=chat, text="High")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"programming skill - High")
u = self.mg.get_message(user=user, chat=chat, text="Done")
self.bot.insertUpdate(u)
data = self.bot.sent_messages[-1]
self.assertRegexpMatches(data['text'], r"programming skill - High")
self.assertRegexpMatches(data['text'], r"Age - 23")
self.updater.stop()
