def test_get_question_exists(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock
request.args = {'question': 'Hello'}
key = client.get_question(request)
self.assertIsNotNone(key)
self.assertEqual('Hello', key)
def test_process_debug_request_no_conversation(self):
arguments = MockArgumentParser()
client = SanicYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.body = b'{"userId": "1234567890", "variables": [{"type": "name", "key": "testname", "value": "value1"}]}'
debugInfo, status = client.process_debug_request(request)
self.assertEqual(0, len(debugInfo))
self.assertEqual(200, status)
def test_api_keys(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
client.initialise()
client.api_keys.api_keys = ['KEY1', 'KEY2']
self.assertTrue(client.api_keys.is_apikey_valid('KEY1'))
self.assertTrue(client.api_keys.is_apikey_valid('KEY2'))
self.assertFalse(client.api_keys.is_apikey_valid('KEY3'))
def test_get_api_key_not_exists(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
client.initialise()
request = unittest.mock.Mock
request.args = {}
key = client.api_keys.get_api_key(request)
self.assertIsNone(key)
def test_parse_direct_mention(self):
arguments = MockArgumentParser()
client = MockSlackBotClient(arguments)
text = "<@U024BE7LH> Hello"
userid, message = client.parse_direct_mention(text)
self.assertIsNotNone(userid)
self.assertEquals("U024BE7LH", userid)
self.assertIsNotNone(message)
self.assertEquals("Hello", message)
def test_get_userid_missing(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
client.initialise()
request = unittest.mock.Mock()
request.cookies = unittest.mock.Mock()
request.cookies.get.return_value = None
self.assertIsNotNone(client.get_userid(request))
def test_init(self):
arguments = MockArgumentParser()
client = RestBotClient("testrest", arguments)
self.assertIsNotNone(client)
self.assertIsNotNone(client.get_client_configuration())
self.assertIsInstance(client.get_client_configuration(),
RestConfiguration)
self.assertEqual([], client.api_keys)
request = unittest.mock.Mock()
response, code = client.process_request(request)
def test_extract_payload(self):
arguments = MockArgumentParser()
client = MockSocketBotClient(MockSocket(), arguments)
receive_payload = {"userid": "user12345", "question": "Test Question"}
question = client.extract_question(receive_payload)
self.assertEqual("Test Question", question)
userid = client.extract_userid(receive_payload)
self.assertEqual("user12345", userid)
def test_verify_api_key_usage_active(self):
arguments = MockArgumentParser()
client = FlaskYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
client.configuration.client_configuration._use_api_keys = True
client.configuration.client_configuration._api_key_file = os.path.dirname(__file__) + os.sep + ".." + os.sep + ".." + os.sep + "api_keys.txt"
client.load_api_keys()
request = unittest.mock.Mock()
request.args = {}
request.args['apikey'] = '11111111'
self.assertEqual(({'error': 'Unauthorized access'}, 401), client.verify_api_key_usage(request))
def test_verify_api_key_usage_active_invalid_apikey(self):
arguments = MockArgumentParser()
client = MockFlaskYadlanClient(arguments)
client.configuration.client_configuration._use_api_keys = True
request = unittest.mock.Mock()
request.args = {}
request.args['apikey'] = 'invalid'
response = client.verify_api_key_usage(request)
self.assertIsNotNone(response)
def test_twitter_get_username(self):
arguments = MockArgumentParser()
client = TwitterBotClient(arguments)
self.assertIsNotNone(client)
bot = MockBot()
bot.license_keys = MockLicenseKeys({"TWITTER_USERNAME": "******"})
client._get_username(bot)
self.assertEquals("Username", client._username)
self.assertEquals(8, client._username_len)
def test_xmpp_bot_client_init(self):
arguments = MockArgumentParser()
client = MockXmppBotClient(arguments)
self.assertIsNotNone(client)
self.assertIsNotNone(client.get_client_configuration())
self.assertIsInstance(client.get_client_configuration(), XmppConfiguration)
self.assertEquals('ProgramY AIML2.0 XMPP Client', client.get_description())
self.assertEquals('XMPPUSERNAME', client._username)
self.assertEquals('XMPPPASSWORD', client._password)
self.assertEqual("Server", client._server)
self.assertEqual(8080, client._port)
def test_return_hub_challenge(self):
arguments = MockArgumentParser()
client = MockFacebookBotClient(arguments)
request = unittest.mock.Mock()
request.args = unittest.mock.Mock()
request.args.get.return_value = "ZZZZZZ"
client._verify_token = "ZZZZZZ"
self.assertEqual("ZZZZZZ", client.return_hub_challenge(request))
def test_format_success_response(self):
arguments = MockArgumentParser()
client = SanicRestBotClient(arguments)
self.assertIsNotNone(client)
response = client.format_success_response("1234567890", "Hello",
"Hi")
self.assertIsNotNone(response)
self.assertEquals("1234567890", response['sessionid'])
self.assertEquals("Hello", response['question'])
self.assertEquals("Hi", response['answer'])
def test_process_debug_request_invalid_variables_type(self):
arguments = MockArgumentParser()
client = SanicYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.body = b'{"userId": "1234567890", "variables": [{"type": "var", "key": "testvar", "value": "value1"}]}'
debugInfo, status = client.process_debug_request(request)
self.assertEqual('Invalid variables list format', debugInfo['error'])
self.assertEqual(400, status)
def test_get_api_key_exists(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock
request.args = {'api_key': 'KEY1'}
key = client.get_api_key(request)
self.assertIsNotNone(key)
self.assertEqual('KEY1', key)
def test_webchat_client_init(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
client.initialise()
self.assertIsInstance(client.get_client_configuration(),
WebChatConfiguration)
self.assertEqual('ProgramY AIML2.0 Client', client.get_description())
self.assertFalse(client._render_callback())
self.assertIsInstance(client.renderer, HtmlRenderer)
def test_checkBotVersion(self):
arguments = MockArgumentParser()
client = MockFlaskYadlanClient(arguments)
self.assertIsNotNone(client)
self.assertEqual(False, client.checkBotVersion('v1.0'))
bot = client._bot_factory.select_bot()
bot.configuration._version = 'v1.0'
self.assertEqual(True, client.checkBotVersion('v1.0'))
self.assertEqual(False, client.checkBotVersion('v1 0'))
def test_check_api_key_required_key_missing(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock
request.args = {}
client.configuration.client_configuration._use_api_keys = True
client.api_keys.api_keys = ['KEY1']
self.assertFalse(client.api_keys.verify_api_key_usage(request))
def test_get_userid_none_userid(self):
arguments = MockArgumentParser()
client = MockFlaskYadlanClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.data = b'{"userId": null}'
self.assertEqual("None", client.get_userid(request))
request.data = b'{"userId": ""}'
self.assertEqual("None", client.get_userid(request))
def test_process_request_no_question(self):
arguments = MockArgumentParser()
client = FlaskYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.args = {}
request.data = b'{"userId": "1234567890"}'
response, status = client.process_request(request)
self.assertIsNotNone(response)
self.assertEqual(status, 400)
def test_format_error_response(self):
arguments = MockArgumentParser()
client = SanicRestBotClient("sanic", arguments)
self.assertIsNotNone(client)
response = client.format_error_response("1234567890", "Hello",
"Something Bad")
self.assertIsNotNone(response)
self.assertEqual("1234567890", response['userid'])
self.assertEqual("Hello", response['question'])
self.assertEqual("", response['answer'])
self.assertEqual("Something Bad", response['error'])
def test_get_sessionid_no_sessionid(self):
arguments = MockArgumentParser()
client = MockSanicRestBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.raw_args = {}
self.assertFalse(client.aborted)
with self.assertRaises(Exception):
self.assertEquals("1234567890", client.get_sessionid(request))
self.assertTrue(client.aborted)
def test_handle_message(self):
arguments = MockArgumentParser()
client = MockSlackBotClient(arguments)
client._starterbot_id = "U024BE7LH"
client.test_question = "Hi there"
client.handle_message("Hello", "test", "U024BE7LH")
self.assertIsNotNone(client.response_sent)
self.assertEqual("Hi there", client.response_sent)
self.assertIsNotNone(client.channel_sent)
self.assertEqual("test", client.channel_sent)
def test_get_question_none_question(self):
arguments = MockArgumentParser()
client = MockSanicRestBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.raw_args = {}
self.assertFalse(client.aborted)
with self.assertRaises(Exception):
self.assertEqual("Hello", client.get_question(request))
self.assertTrue(client.aborted)
def test_twilio_client_init(self):
arguments = MockArgumentParser()
client = MockTwilioBotClient(arguments)
self.assertIsNotNone(client)
self.assertEqual("TWILIO_ACCOUNT_SID", client._account_sid)
self.assertEqual("TWILIO_AUTH_TOKEN", client._auth_token)
self.assertEqual("+447777777777", client._from_number)
self.assertIsInstance(client.get_client_configuration(), TwilioConfiguration)
self.assertIsInstance(client._twilio_client, Client)
def test_slack_client_init(self):
arguments = MockArgumentParser()
client = MockSlackBotClient(arguments)
self.assertIsNotNone(client)
self.assertEqual("SLACK_BOT_TOKEN", client._bot_token)
self.assertEqual('ProgramY AIML2.0 Client', client.get_description())
self.assertIsInstance(client.get_client_configuration(),
SlackConfiguration)
self.assertIsInstance(client._slack_client, SlackClient)
self.assertFalse(client._render_callback())
self.assertIsInstance(client.renderer, TextRenderer)
def test_poll_answer(self):
telegram_bot = MockTelegramBot()
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
client.connect()
self.assertFalse(client._updater._ran)
client.poll_and_answer()
self.assertTrue(client._updater._ran)
def test_telegram_client_init(self):
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
self.assertIsInstance(client.get_client_configuration(),
TelegramConfiguration)
self.assertEqual(client.id, "telegram")
self.assertEqual('ProgramY AIML2.0 Client', client.get_description())
self.assertEqual("TELEGRAM_TOKEN", client._telegram_token)
self.assertFalse(client._render_callback())
self.assertIsInstance(client.renderer, TextRenderer)
def test_get_question_from_text(self):
arguments = MockArgumentParser()
client = MockTwitterBotClient(arguments)
self.assertIsNotNone(client)
self.assertTrue(client.connect())
client._username = "******"
client._username_len = 9
self.assertEqual("Hello", client._get_question_from_text("@keiffster Hello"))
self.assertIsNone(client._get_question_from_text("keiffster Hello"))
self.assertIsNone(client._get_question_from_text("Hello"))
