def main(): updater = Updater(man.settings["authkey"]) dp = updater.dispatcher dp.addTelegramCommandHandler("reactio", reactio) dp.addTelegramCommandHandler("kuva", kuva) #dp.addTelegramCommandHandler("kiusua", insult) #dp.addTelegramCommandHandler("new_insult", new_insult) dp.addTelegramMessageHandler(jutku) dp.addErrorHandler(error) update_queue = updater.start_polling(poll_interval=0.1, timeout=10) while True: try: text = input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
def main(): config = configparser.ConfigParser() config.read('info.ini') token = config.get("Connection","Token") updater = Updater(token, workers=10) dp = updater.dispatcher dp.addUnknownTelegramCommandHandler(unknown_command) dp.addTelegramMessageHandler(message) dp.addTelegramRegexHandler('.*', any_message) dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) dp.addErrorHandler(error) update_queue = updater.start_polling(poll_interval=0.1, timeout=10) # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() if text == 'stop': fileids.close() updater.stop() break elif len(text) > 0: update_queue.put(text)
def main(): # Create the EventHandler and pass it your bot's token. token = os.environ["TOKEN"] updater = Updater(token, workers=10) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("blue", blue) dp.addStringCommandHandler("reply", cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler("[^/].*", cli_noncommand) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=20) # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == "stop": updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): config = configparser.ConfigParser() config.read('info.ini') token = config.get("Connection", "Token") updater = Updater(token, workers=10) dp = updater.dispatcher dp.addUnknownTelegramCommandHandler(unknown_command) dp.addTelegramMessageHandler(message) dp.addTelegramRegexHandler('.*', any_message) dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) dp.addErrorHandler(error) update_queue = updater.start_polling(poll_interval=0.1, timeout=10) # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() if text == 'stop': fileids.close() updater.stop() break elif len(text) > 0: update_queue.put(text)
def main(): ### Updater será vinculado ao token informado, ### no caso, o token do grupo Brail Linux se não ### for mais release candidate if RELEASE_CANDIDATE: TOKEN2USE = TOKEN['rc'] else: TOKEN2USE = TOKEN['released'] updater = Updater(TOKEN2USE , workers=10) # Get the dispatcher to register handlers (funcoes...) dp = updater.dispatcher ### Adiciona comandos ao handler... ### Loop pela lista com todos comandos for lc in ALL_COMMANDS: add_handler(dp, lc, isADM=False) ### Adiciona comandos adm ao handler ### É preciso por o flag isADM como true... for lca in ALL_COMMANDS_ADMS: add_handler(dp, lca, isADM=True) ### aqui tratamos comandos não reconhecidos. ### Tipicamente comandos procedidos por "/" que é o caracter ### default para comandos telegram dp.addUnknownTelegramCommandHandler(showUnknowncommand) ### Loga todas mensagens para o terminal ### Pode ser util para funcoes anti-flood dp.addTelegramMessageHandler(message) ### Aqui logamos todos erros que possam vir a acontecer... dp.addErrorHandler(errosHandler) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=10) ### Aqui lemos o dicionarios de usuarios do disco ##- global USERS ##- USERS = logging.info('Quantia de users no DB: {udb}.'.format(udb=len(USERS))) for u in USERS: logging.info('User {un}, id: {uid}'.format(un=USERS[u]['username'],uid=u)) # Start CLI-Loop and heartbeat while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
def main(): #Get bot token. Config = ConfigParser.ConfigParser() Config.read("./jabberwocky.cfg") #Create event handler updater = Updater(Config.get("BotApi", "Token")) dp = updater.dispatcher #Add handlers dp.addTelegramMessageHandler(parseMessage) dp.addTelegramCommandHandler("apologize", apologize) #Start up bot. updater.start_polling() while True: if debug: cmd = raw_input("Enter command...\n") if cmd == 'list': print 'Nouns:' print nouns.values print 'Verbs:' print verbs.values print 'Adverbs:' print adverbs.values print 'Numbers:' print numbers.values print 'Adjectives:' print adjectives.values print 'Garbage:' print garbage.values #Force generation of a random sentence. elif cmd == 'forceprint': m = markov.Markov(nouns, adjectives, verbs, adverbs, numbers, pronouns, prepositions, conjunctions, vowels, garbage) print m.string #Shutdown bot. elif cmd == 'quit': updater.stop() sys.exit() elif cmd == 'help': print 'Commands are: list, forceprint, quit.' else: print 'Commmand not recognized.' else: time.sleep(1)
def test_inUpdater(self): u = Updater(bot="MockBot", job_queue_tick_interval=0.005) u.job_queue.put(self.job1, 0.5) sleep(0.75) self.assertEqual(1, self.result) u.stop() sleep(2) self.assertEqual(1, self.result)
def test_inUpdater(self): u = Updater(bot="MockBot", job_queue_tick_interval=0.005) u.job_queue.put(self.job1, 0.5) sleep(0.75) self.assertEqual(1, self.result) u.stop() sleep(2) self.assertEqual(1, self.result)
def test_inUpdater(self): print('Testing job queue created by updater') u = Updater(bot="MockBot", job_queue_tick_interval=0.005) u.job_queue.put(self.job1, 0.1) sleep(0.15) self.assertEqual(1, self.result) u.stop() sleep(0.4) self.assertEqual(1, self.result)
def test_inUpdater(self): print('Testing job queue created by updater') u = Updater(bot="MockBot", job_queue_tick_interval=0.005) u.job_queue.put(self.job1, 0.1) sleep(0.15) self.assertEqual(1, self.result) u.stop() sleep(0.4) self.assertEqual(1, self.result)
def main(): # Create the EventHandler and pass it your bot's token. token = 'token' updater = Updater(token, workers=2) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("help", help) dp.addUnknownTelegramCommandHandler(unknown_command) dp.addTelegramMessageHandler(message) dp.addTelegramRegexHandler('.*', any_message) dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=20) ''' # Alternatively, run with webhook: updater.bot.setWebhook(webhook_url='https://example.com/%s' % token, certificate=open('cert.pem', 'rb')) update_queue = updater.start_webhook('0.0.0.0', 443, url_path=token, cert='cert.pem', key='key.key') # Or, if SSL is handled by a reverse proxy, the webhook URL is already set # and the reverse proxy is configured to deliver directly to port 6000: update_queue = updater.start_webhook('0.0.0.0', 6000) ''' # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): # Create the Updater and pass it your bot's token. updater = Updater(TOKEN, workers=2) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", help) dp.addTelegramCommandHandler("help", help) dp.addTelegramCommandHandler('welcome', set_welcome) dp.addTelegramCommandHandler('goodbye', set_goodbye) dp.addTelegramCommandHandler('disable_goodbye', disable_goodbye) dp.addTelegramCommandHandler("lock", lock) dp.addTelegramCommandHandler("unlock", unlock) dp.addTelegramCommandHandler("quiet", quiet) dp.addTelegramCommandHandler("unquiet", unquiet) dp.addTelegramRegexHandler('^$', empty_message) dp.addStringCommandHandler('broadcast', broadcast) dp.addStringCommandHandler('level', set_log_level) dp.addStringCommandHandler('count', chatcount) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=1, timeout=5) ''' # Alternatively, run with webhook: updater.bot.setWebhook(webhook_url='https://%s/%s' % (BASE_URL, TOKEN)) # Or, if SSL is handled by a reverse proxy, the webhook URL is already set # and the reverse proxy is configured to deliver directly to port 6000: update_queue = updater.start_webhook(HOST, PORT, url_path=TOKEN) ''' # Start CLI-Loop while True: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): # Create the Updater and pass it your bot's token. updater = Updater(TOKEN, workers=2) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", help) dp.addTelegramCommandHandler("help", help) dp.addTelegramCommandHandler('welcome', set_welcome) dp.addTelegramCommandHandler('goodbye', set_goodbye) dp.addTelegramCommandHandler('disable_goodbye', disable_goodbye) dp.addTelegramCommandHandler("lock", lock) dp.addTelegramCommandHandler("unlock", unlock) dp.addTelegramCommandHandler("quiet", quiet) dp.addTelegramCommandHandler("unquiet", unquiet) dp.addTelegramRegexHandler('^$', empty_message) dp.addStringCommandHandler('broadcast', broadcast) dp.addStringCommandHandler('level', set_log_level) dp.addStringCommandHandler('count', chatcount) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=1, timeout=5) ''' # Alternatively, run with webhook: updater.bot.setWebhook(webhook_url='https://%s/%s' % (BASE_URL, TOKEN)) # Or, if SSL is handled by a reverse proxy, the webhook URL is already set # and the reverse proxy is configured to deliver directly to port 6000: update_queue = updater.start_webhook(HOST, PORT, url_path=TOKEN) ''' # Start CLI-Loop while True: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): # Create the EventHandler and pass it your bot's token. updater = Updater("TOKEN", workers=2) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("help", help) dp.addUnknownTelegramCommandHandler(unknown_command) dp.addTelegramMessageHandler(message) dp.addTelegramRegexHandler('.*', any_message) dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=20) ''' # Alternatively, run with webhook: update_queue = updater.start_webhook('example.com', 443, 'cert.pem', 'key.key', listen='0.0.0.0') ''' # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): # Create the EventHandler and pass it your bot's token. updater = Updater("TOKEN", workers=2) # Get the dispatcher to register handlers dp = updater.dispatcher dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("help", help) dp.addUnknownTelegramCommandHandler(unknown_command) dp.addTelegramMessageHandler(message) dp.addTelegramRegexHandler('.*', any_message) dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=20) ''' # Alternatively, run with webhook: update_queue = updater.start_webhook('example.com', 443, 'cert.pem', 'key.key', listen='0.0.0.0') ''' # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue elif len(text) > 0: update_queue.put(text) # Put command into queue
def main(): updater = Updater(man.settings["authkey"]) #brew bot #updater = Updater(man.settings["authkey_gmfrpg"]) #gmf rpg dp = updater.dispatcher j_que = updater.job_queue j_que.put(brew_timer, 1) j_que.put(illumi_time, 2) j_que.put(msg_que, 10) print("Brew 0.8 + Items&Drops DLC + ILLUMICOFFEE") dp.addTelegramCommandHandler("brew", brew) dp.addTelegramCommandHandler("brew_stats", brew_stats) dp.addTelegramCommandHandler("brew_score", brew_score) dp.addTelegramCommandHandler("brew_check", brew_check) dp.addTelegramCommandHandler("brew_inventory", brew_inventory) dp.addTelegramCommandHandler("brew_remove", brew_remove) dp.addTelegramCommandHandler("brew_cons", brew_cons) dp.addTelegramCommandHandler("brew_help", brew_help) dp.addTelegramCommandHandler("brew_status", brew_status) dp.addTelegramCommandHandler("rahka", rahka) dp.addTelegramCommandHandler("illuminati", illuminati) dp.addTelegramCommandHandler("illumi_shop", illumi_shop) dp.addTelegramCommandHandler("give_money", give_money) dp.addTelegramCommandHandler("terästä", terasta) dp.addTelegramCommandHandler("brew_notify", brew_notify) dp.addTelegramCommandHandler("brew_cancel", brew_cancel) dp.addErrorHandler(error) update_queue = updater.start_polling(poll_interval=2, timeout=10) while True: try: text = input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
def main(): updater = Updater(man.settings["authkey"]) #brew bot #updater = Updater(man.settings["authkey_gmfrpg"]) #gmf rpg dp = updater.dispatcher j_que = updater.job_queue j_que.put(brew_timer, 1) j_que.put(msg_que, 2) print("Brew 0.80 + Items&Drops DLC 2.0 + ILLUMICOFFEE") dp.addTelegramCommandHandler("brew", brew) dp.addTelegramCommandHandler("brew_stats", brew_stats) dp.addTelegramCommandHandler("brew_score", brew_score) dp.addTelegramCommandHandler("brew_check", brew_check) dp.addTelegramCommandHandler("brew_inventory", brew_inventory) dp.addTelegramCommandHandler("brew_cons", brew_cons) dp.addTelegramCommandHandler("brew_help", brew_help) dp.addTelegramCommandHandler("brew_status", brew_status) dp.addTelegramCommandHandler("rahka", rahka) dp.addTelegramCommandHandler("illuminati", illuminati) dp.addTelegramCommandHandler("illumi_shop", illumi_shop) dp.addTelegramCommandHandler("give_money", give_money) dp.addTelegramCommandHandler("terästä", terasta) dp.addTelegramCommandHandler("brew_notify", brew_notify) dp.addTelegramCommandHandler("brew_cancel", brew_cancel) dp.addErrorHandler(error) update_queue = updater.start_polling(poll_interval=2, timeout=10) while True: try: text = input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
def main(): settings = file('minecraftsettings.yml', 'r') yaml_data = yaml.load(settings) token = yaml_data['telegram-apikey'] updater = Updater(token) disp = updater.dispatcher updater.start_polling() # Register commands disp.addTelegramCommandHandler('ping', ping_command) disp.addTelegramCommandHandler('start', start_command) # CLI while True: try: text = raw_input() except NameError: text = input() if text == 'stop': updater.stop() break
def main(): #Get bot token. Config = ConfigParser.ConfigParser() Config.read("./jabberwocky.cfg") #Create event handler updater = Updater(Config.get("BotApi", "Token")) dp = updater.dispatcher #Add handlers dp.addTelegramMessageHandler(parseMessage) dp.addTelegramCommandHandler("apologize", apologize) #Start up bot. updater.start_polling() while True: if debug: cmd = raw_input("Enter command...\n") if cmd == 'list': print 'Nouns:' print nouns.values print 'Verbs:' print verbs.values print 'Adverbs:' print adverbs.values print 'Numbers:' print numbers.values print 'Adjectives:' print adjectives.values print 'Garbage:' print garbage.values #Force generation of a random sentence. elif cmd == 'forceprint': m = markov.Markov(nouns, adjectives, verbs, adverbs, numbers, pronouns, prepositions, conjunctions, vowels, garbage) print m.string #Shutdown bot. elif cmd == 'quit': updater.stop() sys.exit() elif cmd == 'help': print 'Commands are: list, forceprint, quit.' else: print 'Commmand not recognized.' else: time.sleep(1)
reply = 'Nomnomnomnomnomnomnom' elif ('what' in text_l) and ('do' in text_l): reply = 'I can now control music on Ashwin\'s computer! :D\n'\ 'I can understand the commands:\n'\ '1. Play\n2. Pause\n3. Next\n4. Previous\n'\ '5. Louder or Volume Up\n6. Softer or Volume Down\n'\ '7. Mute\n8. Unmute\n9. Shuffle\n10.Unshuffle\n'\ 'I can also tell you track is currently playing. Just'\ ' ask me "What\'s playing?"' else: reply = text_l if act_reply and reply: reply += '\n\n----------------------\n' reply += act_reply else: reply += act_reply return reply def handle_response(bot, update): reply = decideResponse(update) bot.sendMessage(chat_id=update.message.chat_id, text=reply) updater = Updater(token=key) dispatcher = updater.dispatcher dispatcher.addTelegramMessageHandler(handle_response) updater.start_polling(3.0) time.sleep(120) updater.stop()
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = None self.received_message = None self.message_count = 0 self.lock = Lock() def _setup_updater(self, *args, **kwargs): bot = MockBot(*args, **kwargs) self.updater = Updater(workers=2, bot=bot) def tearDown(self): if self.updater is not None: self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 def telegramInlineHandlerTest(self, bot, update): self.received_message = (update.inline_query, update.chosen_inline_result) self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update, **kwargs): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None): self.received_message = (groups, groupdict) self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == 'resend': update_queue.put('/test5 noresend') elif args[0] == 'noresend': pass def contextTest(self, bot, update, context): self.received_message = update self.message_count += 1 self.context = context @run_async def asyncAdditionalHandlerTest(self, bot, update, update_queue=None, **kwargs): sleep(1) with self.lock: if update_queue is not None: self.received_message = update.message.text self.message_count += 1 def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): self._setup_updater('Test') d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test') # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): self._setup_updater('Multiple', 100) self.updater.dispatcher.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(2) self.assertEqual(self.received_message, 'Multiple') self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): self._setup_updater('Test2') d = self.updater.dispatcher regobj = re.compile('Te.*') self.updater.dispatcher.addTelegramRegexHandler( regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test2') # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): self._setup_updater('/test') d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler( 'test', self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test') # Remove handler d.removeTelegramCommandHandler('test', self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): self._setup_updater('/test2') d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test2') # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('Te.*', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test3') sleep(.1) self.assertEqual(self.received_message, 'Test3') # Remove handler d.removeStringRegexHandler('Te.*', self.stringHandlerTest) self.reset() queue.put('Test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringCommandHandler('test3', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test3') sleep(.1) self.assertEqual(self.received_message, '/test3') # Remove handler d.removeStringCommandHandler('test3', self.stringHandlerTest) self.reset() queue.put('/test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): self._setup_updater('/test') d = self.updater.dispatcher d.addUnknownStringCommandHandler(self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test4') sleep(.1) self.assertEqual(self.received_message, '/test4') # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('.*', self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test Error 1') sleep(.1) self.assertEqual(self.received_message, 'Test Error 1') def test_cleanBeforeStart(self): self._setup_updater('') d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01, clean=True) sleep(.1) self.assertEqual(self.message_count, 0) self.assertIsNone(self.received_message) def test_errorOnGetUpdates(self): self._setup_updater('', raise_error=True) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveInlineHandlerQuery(self): print('Testing add/removeInlineHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addTelegramInlineHandler(self.telegramInlineHandlerTest) queue = self.updater.start_polling(0.01) update = Update(update_id=0, inline_query="testquery") update2 = Update(update_id=0, chosen_inline_result="testresult") queue.put(update) sleep(.1) self.assertEqual(self.received_message[0], "testquery") queue.put(update2) sleep(.1) self.assertEqual(self.received_message[1], "testresult") # Remove handler d.removeTelegramInlineHandler(self.telegramInlineHandlerTest) self.reset() queue.put(update) sleep(.1) self.assertTrue(None is self.received_message) def test_runAsync(self): self._setup_updater('Test5', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test5') self.assertEqual(self.message_count, 2) def test_additionalArgs(self): self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test5', self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put('/test5 resend') sleep(.1) self.assertEqual(self.received_message, '/test5 noresend') self.assertEqual(self.message_count, 2) def test_context(self): context = "context_data" self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test_context', self.contextTest) queue = self.updater.start_polling(0.01) queue.put('/test_context', context=context) sleep(.5) self.assertEqual(self.received_message, '/test_context') self.assertEqual(self.message_count, 1) self.assertEqual(self.context, context) def test_regexGroupHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('^(This).*?(?P<testgroup>regex group).*', self.regexGroupHandlerTest) queue = self.updater.start_polling(0.01) queue.put('This is a test message for regex group matching.') sleep(.1) self.assertEqual(self.received_message, (('This', 'regex group'), { 'testgroup': 'regex group' })) def test_runAsyncWithAdditionalArgs(self): self._setup_updater('Test6', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncAdditionalHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test6') self.assertEqual(self.message_count, 2) def test_webhook(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, 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 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): 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_invalid_posts(self): self._setup_updater('', messages=0) ip = '127.0.0.1' port = randrange(1024, 49152) # select random port for travis thr = Thread(target=self.updater._start_webhook, args=(ip, port, '', None, None)) thr.start() sleep(0.5) try: with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, '<root><bla>data</bla></root>', content_type='application/xml') self.assertEqual(ctx.exception.code, 403) with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, 'dummy-payload', content_len=-2) self.assertEqual(ctx.exception.code, 403) # TODO: prevent urllib or the underlying from adding content-length # with self.assertRaises(HTTPError) as ctx: # self._send_webhook_msg(ip, port, 'dummy-payload', # content_len=None) # self.assertEqual(ctx.exception.code, 411) with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, 'dummy-payload', content_len='not-a-number') self.assertEqual(ctx.exception.code, 403) finally: self.updater._stop_httpd() thr.join() def _send_webhook_msg(self, ip, port, payload_str, url_path='', content_len=-1, content_type='application/json', get_method=None): headers = { 'content-type': content_type, } if not payload_str: content_len = None payload = None else: payload = bytes(payload_str, encoding='utf-8') if content_len == -1: content_len = len(payload) if content_len is not None: headers['content-length'] = str(content_len) url = 'http://{ip}:{port}/{path}'.format(ip=ip, port=port, path=url_path) req = Request(url, data=payload, headers=headers) if get_method is not None: req.get_method = get_method return urlopen(req) def signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): self._setup_updater('Test6', messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.assertFalse(self.updater.running) def test_createBot(self): updater = Updater('123:abcd') self.assertIsNotNone(updater.bot) def test_mutualExclusiveTokenBot(self): bot = Bot('123:zyxw') self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot) def test_noTokenOrBot(self): self.assertRaises(ValueError, Updater)
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = None self.received_message = None self.message_count = 0 self.lock = Lock() def _setup_updater(self, *args, **kwargs): bot = MockBot(*args, **kwargs) self.updater = Updater(workers=2, bot=bot) def tearDown(self): if self.updater is not None: self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update, **kwargs): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None): self.received_message = (groups, groupdict) self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == 'resend': update_queue.put('/test5 noresend') elif args[0] == 'noresend': pass def contextTest(self, bot, update, context): self.received_message = update self.message_count += 1 self.context = context @run_async def asyncAdditionalHandlerTest(self, bot, update, update_queue=None, **kwargs): sleep(1) with self.lock: if update_queue is not None: self.received_message = update.message.text self.message_count += 1 def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): print('Testing add/removeTelegramMessageHandler') self._setup_updater('Test') d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test') # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): print('Testing addTelegramMessageHandler and send 100 messages...') self._setup_updater('Multiple', 100) self.updater.dispatcher.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(2) self.assertEqual(self.received_message, 'Multiple') self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): print('Testing add/removeStringRegexHandler') self._setup_updater('Test2') d = self.updater.dispatcher regobj = re.compile('Te.*') self.updater.dispatcher.addTelegramRegexHandler( regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test2') # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): print('Testing add/removeTelegramCommandHandler') self._setup_updater('/test') d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler( 'test', self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test') # Remove handler d.removeTelegramCommandHandler('test', self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): print('Testing add/removeUnknownTelegramCommandHandler') self._setup_updater('/test2') d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test2') # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): print('Testing add/removeStringRegexHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('Te.*', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test3') sleep(.1) self.assertEqual(self.received_message, 'Test3') # Remove handler d.removeStringRegexHandler('Te.*', self.stringHandlerTest) self.reset() queue.put('Test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): print('Testing add/removeStringCommandHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringCommandHandler('test3', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test3') sleep(.1) self.assertEqual(self.received_message, '/test3') # Remove handler d.removeStringCommandHandler('test3', self.stringHandlerTest) self.reset() queue.put('/test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): print('Testing add/removeUnknownStringCommandHandler') self._setup_updater('/test') d = self.updater.dispatcher d.addUnknownStringCommandHandler(self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test4') sleep(.1) self.assertEqual(self.received_message, '/test4') # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): print('Testing add/removeErrorHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): print('Testing error in Handler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('.*', self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test Error 1') sleep(.1) self.assertEqual(self.received_message, 'Test Error 1') def test_errorOnGetUpdates(self): print('Testing error on getUpdates') self._setup_updater('', raise_error=True) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): print('Testing add/removeTypeHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(.1) self.assertTrue(None is self.received_message) def test_runAsync(self): print('Testing @run_async') self._setup_updater('Test5', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test5') self.assertEqual(self.message_count, 2) def test_additionalArgs(self): print('Testing additional arguments for handlers') self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test5', self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put('/test5 resend') sleep(.1) self.assertEqual(self.received_message, '/test5 noresend') self.assertEqual(self.message_count, 2) def test_context(self): print('Testing context for handlers') context = "context_data" self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test_context', self.contextTest) queue = self.updater.start_polling(0.01) queue.put('/test_context', context=context) sleep(.5) self.assertEqual(self.received_message, '/test_context') self.assertEqual(self.message_count, 1) self.assertEqual(self.context, context) def test_regexGroupHandler(self): print('Testing optional groups and groupdict parameters') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('^(This).*?(?P<testgroup>regex group).*', self.regexGroupHandlerTest) queue = self.updater.start_polling(0.01) queue.put('This is a test message for regex group matching.') sleep(.1) self.assertEqual(self.received_message, (('This', 'regex group'), { 'testgroup': 'regex group' })) def test_runAsyncWithAdditionalArgs(self): print('Testing @run_async with additional parameters') self._setup_updater('Test6', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncAdditionalHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test6') self.assertEqual(self.message_count, 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_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 signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): print('Testing idle') self._setup_updater('Test6', messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.updater.running = False def test_createBot(self): updater = Updater('123:abcd') self.assertIsNotNone(updater.bot) def test_mutualExclusiveTokenBot(self): bot = Bot('123:zyxw') self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot) def test_noTokenOrBot(self): self.assertRaises(ValueError, Updater)
def main(): # Create the EventHandler and pass it your bot's token. token = 'TOKEN' updater = Updater(token, workers=10) # Get the dispatcher to register handlers dp = updater.dispatcher # This is how we add handlers for Telegram messages dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("help", help) dp.addUnknownTelegramCommandHandler(unknown_command) # Message handlers only receive updates that don't contain commands dp.addTelegramMessageHandler(message) # Regex handlers will receive all updates on which their regex matches dp.addTelegramRegexHandler('.*', any_message) # String handlers work pretty much the same dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) # All TelegramErrors are caught for you and delivered to the error # handler(s). Other types of Errors are not caught. dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=10) ''' # Alternatively, run with webhook: updater.bot.setWebhook(webhook_url='https://example.com/%s' % token, certificate=open('cert.pem', 'rb')) update_queue = updater.start_webhook('0.0.0.0', 443, url_path=token, cert='cert.pem', key='key.key') # Or, if SSL is handled by a reverse proxy, the webhook URL is already set # and the reverse proxy is configured to deliver directly to port 6000: update_queue = updater.start_webhook('0.0.0.0', 6000) ''' # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = None self.received_message = None self.message_count = 0 self.lock = Lock() def _setup_updater(self, *args, **kwargs): bot = MockBot(*args, **kwargs) self.updater = Updater(workers=2, bot=bot) def tearDown(self): if self.updater is not None: self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update, **kwargs): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None): self.received_message = (groups, groupdict) self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == "resend": update_queue.put("/test5 noresend") elif args[0] == "noresend": pass def contextTest(self, bot, update, context): self.received_message = update self.message_count += 1 self.context = context @run_async def asyncAdditionalHandlerTest(self, bot, update, update_queue=None, **kwargs): sleep(1) with self.lock: if update_queue is not None: self.received_message = update.message.text self.message_count += 1 def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): print("Testing add/removeTelegramMessageHandler") self._setup_updater("Test") d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(0.1) self.assertEqual(self.received_message, "Test") # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(0.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): print("Testing addTelegramMessageHandler and send 100 messages...") self._setup_updater("Multiple", 100) self.updater.dispatcher.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(2) self.assertEqual(self.received_message, "Multiple") self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): print("Testing add/removeStringRegexHandler") self._setup_updater("Test2") d = self.updater.dispatcher regobj = re.compile("Te.*") self.updater.dispatcher.addTelegramRegexHandler(regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(0.1) self.assertEqual(self.received_message, "Test2") # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): print("Testing add/removeTelegramCommandHandler") self._setup_updater("/test") d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler("test", self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(0.1) self.assertEqual(self.received_message, "/test") # Remove handler d.removeTelegramCommandHandler("test", self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): print("Testing add/removeUnknownTelegramCommandHandler") self._setup_updater("/test2") d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler(self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(0.1) self.assertEqual(self.received_message, "/test2") # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): print("Testing add/removeStringRegexHandler") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addStringRegexHandler("Te.*", self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put("Test3") sleep(0.1) self.assertEqual(self.received_message, "Test3") # Remove handler d.removeStringRegexHandler("Te.*", self.stringHandlerTest) self.reset() queue.put("Test3") sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): print("Testing add/removeStringCommandHandler") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addStringCommandHandler("test3", self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put("/test3") sleep(0.1) self.assertEqual(self.received_message, "/test3") # Remove handler d.removeStringCommandHandler("test3", self.stringHandlerTest) self.reset() queue.put("/test3") sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): print("Testing add/removeUnknownStringCommandHandler") self._setup_updater("/test") d = self.updater.dispatcher d.addUnknownStringCommandHandler(self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put("/test4") sleep(0.1) self.assertEqual(self.received_message, "/test4") # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(0.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): print("Testing add/removeErrorHandler") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(0.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(0.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): print("Testing error in Handler") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addStringRegexHandler(".*", self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put("Test Error 1") sleep(0.1) self.assertEqual(self.received_message, "Test Error 1") def test_errorOnGetUpdates(self): print("Testing error on getUpdates") self._setup_updater("", raise_error=True) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(0.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): print("Testing add/removeTypeHandler") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(0.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(0.1) self.assertTrue(None is self.received_message) def test_runAsync(self): print("Testing @run_async") self._setup_updater("Test5", messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, "Test5") self.assertEqual(self.message_count, 2) def test_additionalArgs(self): print("Testing additional arguments for handlers") self._setup_updater("", messages=0) self.updater.dispatcher.addStringCommandHandler("test5", self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put("/test5 resend") sleep(0.1) self.assertEqual(self.received_message, "/test5 noresend") self.assertEqual(self.message_count, 2) def test_context(self): print("Testing context for handlers") context = "context_data" self._setup_updater("", messages=0) self.updater.dispatcher.addStringCommandHandler("test_context", self.contextTest) queue = self.updater.start_polling(0.01) queue.put("/test_context", context=context) sleep(0.5) self.assertEqual(self.received_message, "/test_context") self.assertEqual(self.message_count, 1) self.assertEqual(self.context, context) def test_regexGroupHandler(self): print("Testing optional groups and groupdict parameters") self._setup_updater("", messages=0) d = self.updater.dispatcher d.addStringRegexHandler("^(This).*?(?P<testgroup>regex group).*", self.regexGroupHandlerTest) queue = self.updater.start_polling(0.01) queue.put("This is a test message for regex group matching.") sleep(0.1) self.assertEqual(self.received_message, (("This", "regex group"), {"testgroup": "regex group"})) def test_runAsyncWithAdditionalArgs(self): print("Testing @run_async with additional parameters") self._setup_updater("Test6", messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncAdditionalHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, "Test6") self.assertEqual(self.message_count, 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_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 signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): print("Testing idle") self._setup_updater("Test6", messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.updater.running = False def test_createBot(self): updater = Updater("123:abcd") self.assertIsNotNone(updater.bot) def test_mutualExclusiveTokenBot(self): bot = Bot("123:zyxw") self.assertRaises(ValueError, Updater, token="123:abcd", bot=bot) def test_noTokenOrBot(self): self.assertRaises(ValueError, Updater)
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = None self.received_message = None self.message_count = 0 self.lock = Lock() def _setup_updater(self, *args, **kwargs): bot = MockBot(*args, **kwargs) self.updater = Updater(workers=2, bot=bot) def tearDown(self): if self.updater is not None: self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 def telegramInlineHandlerTest(self, bot, update): self.received_message = (update.inline_query, update.chosen_inline_result) self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update, **kwargs): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None): self.received_message = (groups, groupdict) self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == 'resend': update_queue.put('/test5 noresend') elif args[0] == 'noresend': pass def contextTest(self, bot, update, context): self.received_message = update self.message_count += 1 self.context = context @run_async def asyncAdditionalHandlerTest(self, bot, update, update_queue=None, **kwargs): sleep(1) with self.lock: if update_queue is not None: self.received_message = update.message.text self.message_count += 1 def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): self._setup_updater('Test') d = self.updater.dispatcher d.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test') # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): self._setup_updater('Multiple', 100) self.updater.dispatcher.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(2) self.assertEqual(self.received_message, 'Multiple') self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): self._setup_updater('Test2') d = self.updater.dispatcher regobj = re.compile('Te.*') self.updater.dispatcher.addTelegramRegexHandler(regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test2') # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): self._setup_updater('/test') d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler( 'test', self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test') # Remove handler d.removeTelegramCommandHandler('test', self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): self._setup_updater('/test2') d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test2') # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('Te.*', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test3') sleep(.1) self.assertEqual(self.received_message, 'Test3') # Remove handler d.removeStringRegexHandler('Te.*', self.stringHandlerTest) self.reset() queue.put('Test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringCommandHandler( 'test3', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test3') sleep(.1) self.assertEqual(self.received_message, '/test3') # Remove handler d.removeStringCommandHandler('test3', self.stringHandlerTest) self.reset() queue.put('/test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): self._setup_updater('/test') d = self.updater.dispatcher d.addUnknownStringCommandHandler( self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test4') sleep(.1) self.assertEqual(self.received_message, '/test4') # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() self.updater.bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('.*', self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test Error 1') sleep(.1) self.assertEqual(self.received_message, 'Test Error 1') def test_cleanBeforeStart(self): self._setup_updater('') d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01, clean=True) sleep(.1) self.assertEqual(self.message_count, 0) self.assertIsNone(self.received_message) def test_errorOnGetUpdates(self): self._setup_updater('', raise_error=True) d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveInlineHandlerQuery(self): print('Testing add/removeInlineHandler') self._setup_updater('', messages=0) d = self.updater.dispatcher d.addTelegramInlineHandler(self.telegramInlineHandlerTest) queue = self.updater.start_polling(0.01) update = Update(update_id=0, inline_query="testquery") update2 = Update(update_id=0, chosen_inline_result="testresult") queue.put(update) sleep(.1) self.assertEqual(self.received_message[0], "testquery") queue.put(update2) sleep(.1) self.assertEqual(self.received_message[1], "testresult") # Remove handler d.removeTelegramInlineHandler(self.telegramInlineHandlerTest) self.reset() queue.put(update) sleep(.1) self.assertTrue(None is self.received_message) def test_runAsync(self): self._setup_updater('Test5', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler( self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test5') self.assertEqual(self.message_count, 2) def test_additionalArgs(self): self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test5', self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put('/test5 resend') sleep(.1) self.assertEqual(self.received_message, '/test5 noresend') self.assertEqual(self.message_count, 2) def test_context(self): context = "context_data" self._setup_updater('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test_context', self.contextTest) queue = self.updater.start_polling(0.01) queue.put('/test_context', context=context) sleep(.5) self.assertEqual(self.received_message, '/test_context') self.assertEqual(self.message_count, 1) self.assertEqual(self.context, context) def test_regexGroupHandler(self): self._setup_updater('', messages=0) d = self.updater.dispatcher d.addStringRegexHandler('^(This).*?(?P<testgroup>regex group).*', self.regexGroupHandlerTest) queue = self.updater.start_polling(0.01) queue.put('This is a test message for regex group matching.') sleep(.1) self.assertEqual(self.received_message, (('This', 'regex group'), {'testgroup': 'regex group'})) def test_runAsyncWithAdditionalArgs(self): self._setup_updater('Test6', messages=2) d = self.updater.dispatcher d.addTelegramMessageHandler( self.asyncAdditionalHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test6') self.assertEqual(self.message_count, 2) def test_webhook(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, 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 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): 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_invalid_posts(self): self._setup_updater('', messages=0) ip = '127.0.0.1' port = randrange(1024, 49152) # select random port for travis thr = Thread(target=self.updater._start_webhook, args=(ip, port, '', None, None)) thr.start() sleep(0.5) try: with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, '<root><bla>data</bla></root>', content_type='application/xml') self.assertEqual(ctx.exception.code, 403) with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, 'dummy-payload', content_len=-2) self.assertEqual(ctx.exception.code, 403) # TODO: prevent urllib or the underlying from adding content-length # with self.assertRaises(HTTPError) as ctx: # self._send_webhook_msg(ip, port, 'dummy-payload', # content_len=None) # self.assertEqual(ctx.exception.code, 411) with self.assertRaises(HTTPError) as ctx: self._send_webhook_msg(ip, port, 'dummy-payload', content_len='not-a-number') self.assertEqual(ctx.exception.code, 403) finally: self.updater._stop_httpd() thr.join() def _send_webhook_msg(self, ip, port, payload_str, url_path='', content_len=-1, content_type='application/json', get_method=None): headers = { 'content-type': content_type, } if not payload_str: content_len = None payload = None else: payload = bytes(payload_str, encoding='utf-8') if content_len == -1: content_len = len(payload) if content_len is not None: headers['content-length'] = str(content_len) url = 'http://{ip}:{port}/{path}'.format(ip=ip, port=port, path=url_path) req = Request(url, data=payload, headers=headers) if get_method is not None: req.get_method = get_method return urlopen(req) def signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): self._setup_updater('Test6', messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.assertFalse(self.updater.running) def test_createBot(self): updater = Updater('123:abcd') self.assertIsNotNone(updater.bot) def test_mutualExclusiveTokenBot(self): bot = Bot('123:zyxw') self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot) def test_noTokenOrBot(self): self.assertRaises(ValueError, Updater)
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = Updater('', workers=2) self.received_message = None self.message_count = 0 self.lock = Lock() def tearDown(self): self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == 'resend': update_queue.put('/test5 noresend') elif args[0] == 'noresend': pass def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): print('Testing add/removeTelegramMessageHandler') bot = MockBot('Test') self.updater.bot = bot d = self.updater.dispatcher d.addTelegramMessageHandler(self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test') # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): print('Testing addTelegramMessageHandler and send 100 messages...') self.updater.bot = MockBot('Multiple', 100) self.updater.dispatcher.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(.5) self.assertEqual(self.received_message, 'Multiple') self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): print('Testing add/removeStringRegexHandler') bot = MockBot('Test2') self.updater.bot = bot d = self.updater.dispatcher regobj = re.compile('Te.*') self.updater.dispatcher.addTelegramRegexHandler( regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test2') # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): print('Testing add/removeTelegramCommandHandler') bot = MockBot('/test') self.updater.bot = bot d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler( 'test', self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test') # Remove handler d.removeTelegramCommandHandler('test', self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): print('Testing add/removeUnknownTelegramCommandHandler') bot = MockBot('/test2') self.updater.bot = bot d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test2') # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): print('Testing add/removeStringRegexHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringRegexHandler('Te.*', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test3') sleep(.1) self.assertEqual(self.received_message, 'Test3') # Remove handler d.removeStringRegexHandler('Te.*', self.stringHandlerTest) self.reset() queue.put('Test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): print('Testing add/removeStringCommandHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringCommandHandler('test3', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test3') sleep(.1) self.assertEqual(self.received_message, '/test3') # Remove handler d.removeStringCommandHandler('test3', self.stringHandlerTest) self.reset() queue.put('/test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): print('Testing add/removeUnknownStringCommandHandler') bot = MockBot('/test') self.updater.bot = bot d = self.updater.dispatcher d.addUnknownStringCommandHandler(self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test4') sleep(.1) self.assertEqual(self.received_message, '/test4') # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): print('Testing add/removeErrorHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): print('Testing error in Handler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringRegexHandler('.*', self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test Error 1') sleep(.1) self.assertEqual(self.received_message, 'Test Error 1') def test_errorOnGetUpdates(self): print('Testing error on getUpdates') bot = MockBot('', raise_error=True) self.updater.bot = bot d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): print('Testing add/removeTypeHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(.1) self.assertTrue(None is self.received_message) def test_runAsync(self): print('Testing @run_async') bot = MockBot('Test5', messages=2) self.updater.bot = bot d = self.updater.dispatcher d.addTelegramMessageHandler(self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test5') self.assertEqual(self.message_count, 2) def test_additionalArgs(self): print('Testing additional arguments for handlers') self.updater.bot = MockBot('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test5', self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put('/test5 resend') sleep(.1) self.assertEqual(self.received_message, '/test5 noresend') self.assertEqual(self.message_count, 2) 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, './tests/test_updater.py', './tests/test_updater.py', listen='127.0.0.1') 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 functionalites...") 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 signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): print('Testing idle') self.updater.bot = MockBot('Test6', messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.updater.running = False
def main(): # Create the EventHandler and pass it your bot's token. token = 'TOKEN' updater = Updater(token, workers=10) # Get the dispatcher to register handlers dp = updater.dispatcher # This is how we add handlers for Telegram messages dp.addTelegramCommandHandler("start", start) dp.addTelegramCommandHandler("help", help) dp.addUnknownTelegramCommandHandler(unknown_command) # Message handlers only receive updates that don't contain commands dp.addTelegramMessageHandler(message) # Regex handlers will receive all updates on which their regex matches dp.addTelegramRegexHandler('.*', any_message) # String handlers work pretty much the same dp.addStringCommandHandler('reply', cli_reply) dp.addUnknownStringCommandHandler(unknown_cli_command) dp.addStringRegexHandler('[^/].*', cli_noncommand) # All TelegramErrors are caught for you and delivered to the error # handler(s). Other types of Errors are not caught. dp.addErrorHandler(error) # Start the Bot and store the update Queue, so we can insert updates update_queue = updater.start_polling(poll_interval=0.1, timeout=10) ''' # Alternatively, run with webhook: updater.bot.setWebhook(webhook_url='https://example.com/%s' % token, certificate=open('cert.pem', 'rb')) update_queue = updater.start_webhook('0.0.0.0', 443, url_path=token, cert='cert.pem', key='key.key') # Or, if SSL is handled by a reverse proxy, the webhook URL is already set # and the reverse proxy is configured to deliver directly to port 6000: update_queue = updater.start_webhook('0.0.0.0', 6000) ''' # Start CLI-Loop while True: try: text = raw_input() except NameError: text = input() # Gracefully stop the event handler if text == 'stop': updater.stop() break # else, put the text into the update queue to be handled by our handlers elif len(text) > 0: update_queue.put(text)
class UpdaterTest(BaseTest, unittest.TestCase): """ This object represents Tests for Updater, Dispatcher, WebhookServer and WebhookHandler """ def setUp(self): self.updater = Updater('', workers=2) self.received_message = None self.message_count = 0 self.lock = Lock() def tearDown(self): self.updater.stop() def reset(self): self.message_count = 0 self.received_message = None def telegramHandlerTest(self, bot, update): self.received_message = update.message.text self.message_count += 1 @run_async def asyncHandlerTest(self, bot, update): sleep(1) with self.lock: self.received_message = update.message.text self.message_count += 1 def stringHandlerTest(self, bot, update): self.received_message = update self.message_count += 1 def additionalArgsTest(self, bot, update, update_queue, args): self.received_message = update self.message_count += 1 if args[0] == 'resend': update_queue.put('/test5 noresend') elif args[0] == 'noresend': pass def errorRaisingHandlerTest(self, bot, update): raise TelegramError(update) def errorHandlerTest(self, bot, update, error): self.received_message = error.message self.message_count += 1 def test_addRemoveTelegramMessageHandler(self): print('Testing add/removeTelegramMessageHandler') bot = MockBot('Test') self.updater.bot = bot d = self.updater.dispatcher d.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test') # Remove handler d.removeTelegramMessageHandler(self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addTelegramMessageHandlerMultipleMessages(self): print('Testing addTelegramMessageHandler and send 100 messages...') self.updater.bot = MockBot('Multiple', 100) self.updater.dispatcher.addTelegramMessageHandler( self.telegramHandlerTest) self.updater.start_polling(0.0) sleep(.5) self.assertEqual(self.received_message, 'Multiple') self.assertEqual(self.message_count, 100) def test_addRemoveTelegramRegexHandler(self): print('Testing add/removeStringRegexHandler') bot = MockBot('Test2') self.updater.bot = bot d = self.updater.dispatcher regobj = re.compile('Te.*') self.updater.dispatcher.addTelegramRegexHandler(regobj, self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, 'Test2') # Remove handler d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveTelegramCommandHandler(self): print('Testing add/removeTelegramCommandHandler') bot = MockBot('/test') self.updater.bot = bot d = self.updater.dispatcher self.updater.dispatcher.addTelegramCommandHandler( 'test', self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test') # Remove handler d.removeTelegramCommandHandler('test', self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownTelegramCommandHandler(self): print('Testing add/removeUnknownTelegramCommandHandler') bot = MockBot('/test2') self.updater.bot = bot d = self.updater.dispatcher self.updater.dispatcher.addUnknownTelegramCommandHandler( self.telegramHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, '/test2') # Remove handler d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringRegexHandler(self): print('Testing add/removeStringRegexHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringRegexHandler('Te.*', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test3') sleep(.1) self.assertEqual(self.received_message, 'Test3') # Remove handler d.removeStringRegexHandler('Te.*', self.stringHandlerTest) self.reset() queue.put('Test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveStringCommandHandler(self): print('Testing add/removeStringCommandHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringCommandHandler( 'test3', self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test3') sleep(.1) self.assertEqual(self.received_message, '/test3') # Remove handler d.removeStringCommandHandler('test3', self.stringHandlerTest) self.reset() queue.put('/test3') sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveUnknownStringCommandHandler(self): print('Testing add/removeUnknownStringCommandHandler') bot = MockBot('/test') self.updater.bot = bot d = self.updater.dispatcher d.addUnknownStringCommandHandler( self.stringHandlerTest) queue = self.updater.start_polling(0.01) queue.put('/test4') sleep(.1) self.assertEqual(self.received_message, '/test4') # Remove handler d.removeUnknownStringCommandHandler(self.stringHandlerTest) self.reset() bot.send_messages = 1 sleep(.1) self.assertTrue(None is self.received_message) def test_addRemoveErrorHandler(self): print('Testing add/removeErrorHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) error = TelegramError("Unauthorized.") queue.put(error) sleep(.1) self.assertEqual(self.received_message, "Unauthorized.") # Remove handler d.removeErrorHandler(self.errorHandlerTest) self.reset() queue.put(error) sleep(.1) self.assertTrue(None is self.received_message) def test_errorInHandler(self): print('Testing error in Handler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addStringRegexHandler('.*', self.errorRaisingHandlerTest) self.updater.dispatcher.addErrorHandler(self.errorHandlerTest) queue = self.updater.start_polling(0.01) queue.put('Test Error 1') sleep(.1) self.assertEqual(self.received_message, 'Test Error 1') def test_errorOnGetUpdates(self): print('Testing error on getUpdates') bot = MockBot('', raise_error=True) self.updater.bot = bot d = self.updater.dispatcher d.addErrorHandler(self.errorHandlerTest) self.updater.start_polling(0.01) sleep(.1) self.assertEqual(self.received_message, "Test Error 2") def test_addRemoveTypeHandler(self): print('Testing add/removeTypeHandler') bot = MockBot('', messages=0) self.updater.bot = bot d = self.updater.dispatcher d.addTypeHandler(dict, self.stringHandlerTest) queue = self.updater.start_polling(0.01) payload = {"Test": 42} queue.put(payload) sleep(.1) self.assertEqual(self.received_message, payload) # Remove handler d.removeTypeHandler(dict, self.stringHandlerTest) self.reset() queue.put(payload) sleep(.1) self.assertTrue(None is self.received_message) def test_runAsync(self): print('Testing @run_async') bot = MockBot('Test5', messages=2) self.updater.bot = bot d = self.updater.dispatcher d.addTelegramMessageHandler( self.asyncHandlerTest) self.updater.start_polling(0.01) sleep(1.2) self.assertEqual(self.received_message, 'Test5') self.assertEqual(self.message_count, 2) def test_additionalArgs(self): print('Testing additional arguments for handlers') self.updater.bot = MockBot('', messages=0) self.updater.dispatcher.addStringCommandHandler( 'test5', self.additionalArgsTest) queue = self.updater.start_polling(0.01) queue.put('/test5 resend') sleep(.1) self.assertEqual(self.received_message, '/test5 noresend') self.assertEqual(self.message_count, 2) 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, './tests/test_updater.py', './tests/test_updater.py', listen='127.0.0.1') 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 functionalites...") 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 signalsender(self): sleep(0.5) os.kill(os.getpid(), signal.SIGTERM) def test_idle(self): print('Testing idle') self.updater.bot = MockBot('Test6', messages=0) self.updater.start_polling(poll_interval=0.01) Thread(target=self.signalsender).start() self.updater.idle() # If we get this far, idle() ran through sleep(1) self.updater.running = False
class KopipasterBot(Kopipaster): def __init__(self, token, wait_coef=0.02): Kopipaster.__init__(self) self.updater = Updater(token=token) self.dispatcher = self.updater.dispatcher self.wait_coef = wait_coef self.tokenizer = nltk.data.load('tokenizers/punkt/english.pickle') self.dispatcher.addTelegramCommandHandler('start', self.start) self.dispatcher.addTelegramCommandHandler('cool', self.coolstory) self.dispatcher.addTelegramCommandHandler('speed', self.set_speed) self.dispatcher.addTelegramCommandHandler('die', self.die) self.dispatcher.addTelegramMessageHandler(self.echo) def send_msg(self, bot, update, msg): time_start = time.time() while(time.time() - time_start < self.wait_coef * len(msg)): bot.sendChatAction(chat_id=update.message.chat_id, action=telegram.ChatAction.TYPING) time.sleep(0.4) bot.sendMessage(chat_id=update.message.chat_id, text=msg) def start(self, bot, update): self.send_msg(bot, update, u"Я - Копипастер, пилю прохладные") def echo(self, bot, update): msg = update.message.text if msg.lower() in [u'пили прохладную', u'рассказывай', u'ну?']: self.coolstory(bot, update) else: self.send_msg(bot, update, msg[::-1]) def coolstory(self, bot, update): story = self.get_coolstory() start_msg = [u'Сап, анон, пилю прохладную', u'Короче, суть такова'] for msg in start_msg: self.send_msg(bot, update, msg) for line in self.tokenizer.tokenize(story): self.send_msg(bot, update, line) self.send_msg(bot, update, u'Вообщем, вот') def die(self, bot, update): bot.sendMessage(chat_id=update.message.chat_id, text=u'А-а-а-а-а!!! Врача!!!\n') def set_speed(self, bot, update): splitted = update.message.text.split() if len(splitted) != 2: self.send_msg(bot, update, u'use /speed value') return try: speed = float(splitted[1]) except: self.send_msg(bot, update, u'use /speed value, value a number') return self.wait_coef = 1.0 / speed def launch(self): self.updater.start_polling() def stop(self): self.updater.stop()