def test_check_api_key_required_key_invalid(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock
request.args = {'KEY2'}
client.configuration.client_configuration._use_api_keys = True
client._api_keys = ['KEY1']
response = client.check_api_key(request)
self.assertIsNotNone(response)
self.assertEqual("Unauthorised Access", response)
def test_client_start_no_initial_question(self):
telegram_bot = MockTelegramBot()
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
client.response = None
message = MockMessage("test123", None)
update = MockUpdate(message)
client.start(telegram_bot, update)
self.assertIsNone(telegram_bot._text)
def test_client_unknown_no_response(self):
telegram_bot = MockTelegramBot()
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
client.response = None
message = MockMessage("test123", None)
update = MockUpdate(message)
client.message(telegram_bot, update)
self.assertIsNone(telegram_bot._text)
def test_handle_message_request(self):
arguments = MockArgumentParser()
client = MockLineBotClient(arguments, line_bot=MockLineApi("TOKEN"), parser=MockWebhookParser("SECRET"))
self.assertIsNotNone(client)
body = '{"events": [{"type": "message", "source": {"source_id": "test", "type": "text", "user": {"user_id": "User123"}}}]}'
signature = "SIGNATURE"
client.handle_message_request(body, signature)
self.assertIsNotNone(client._line_bot_api)
self.assertIsNotNone(client._line_bot_api._messages)
self.assertIsInstance(client._line_bot_api._messages, TextSendMessage)
self.assertEqual("Unknown command", client._line_bot_api._messages.text)
def test_verify_api_key_usage_active(self):
arguments = MockArgumentParser()
client = SanicYadlanClient("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_get_api_key_exists(self):
arguments = MockArgumentParser()
client = MockWebChatBotClient(arguments)
self.assertIsNotNone(client)
client.initialise()
client.api_keys.api_keys = ['KEY1', 'KEY2']
request = unittest.mock.Mock
request.args = {'apikey': 'KEY1'}
key = client.api_keys.get_api_key(request)
self.assertIsNotNone(key)
self.assertEqual('KEY1', key)
def test_receive_message_post(self):
arguments = MockArgumentParser()
client = MockTwilioBotClient(arguments, twilio_client=MockTwilioClient("SID", "TOKEN"))
self.assertIsNotNone(client)
client.test_question = "Hi there"
request = unittest.mock.Mock()
request.method = 'POST'
request.form = {"From": "+447777777888", "Body": "Hello"}
response = client.receive_message(request)
self.assertIsNotNone(response)
self.assertEqual('<?xml version="1.0" encoding="UTF-8"?><Response><Message to="+447777777888">Hi there</Message></Response>', response)
def test_facebook_client_init(self):
arguments = MockArgumentParser()
client = MockFacebookBotClient(arguments)
self.assertIsNotNone(client)
self.assertEquals("FACEBOOK_VERIFY_TOKEN", client._verify_token)
self.assertEquals("FACEBOOK_ACCESS_TOKEN", client._access_token)
self.assertIsInstance(client.get_client_configuration(),
FacebookConfiguration)
self.assertEquals('ProgramY AIML2.0 Facebook Client',
client.get_description())
self.assertIsInstance(client._facebook_bot, FacebookBot)
def test_verify_api_key_usage_active(self):
arguments = MockArgumentParser()
client = SanicRestBotClient("sanic", 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.raw_args = {}
request.raw_args['apikey'] = '11111111'
self.assertEqual((None, None),
client.verify_api_key_usage(request))
def test_receive_message_invalid_message(self):
arguments = MockArgumentParser()
client = MockKikBotClient(arguments,
kik_bot=MockKikApi(bot="test",
api_key="KEY"))
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.headers = MockHeaders()
request.json = {"messages": [{"body": "Hello", "type": "text"}]}
response = client.receive_message(request)
self.assertIsNotNone(response)
self.assertEquals("403 FORBIDDEN", response.status)
def test_handle_message(self):
arguments = MockArgumentParser()
client = MockFacebookBotClient(arguments)
client.test_question = "Hi there"
inner_message = unittest.mock.Mock()
inner_message.get.return_value = "hello"
message = {'message': inner_message, 'sender': {'id': 'user1'}}
client.handle_message(message)
self.assertEquals("user1", client._facebook_bot._recipient_id)
self.assertEquals("Hi there", client._facebook_bot._message)
def test_process_facebook_message(self):
arguments = MockArgumentParser()
client = MockFacebookBotClient(arguments)
client.test_question = "Hi there"
message = unittest.mock.Mock()
message.get.return_value = "hello"
messaging = [{'message': message, 'sender': {'id': 'user1'}}]
client.process_facebook_message(messaging)
self.assertEquals("user1", client._facebook_bot._recipient_id)
self.assertEquals("Hi there", client._facebook_bot._message)
def test_ask_question(self):
arguments = MockArgumentParser()
client = SanicYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
client.configuration.client_configuration._debug = True
request = unittest.mock.Mock()
request.body = b'{"userId": "1234567890", "utterance": "Hello"}'
response, _ = client.process_request(request)
self.assertIsNotNone(response)
self.assertEqual("1234567890", response['userId'])
self.assertEqual("Hello.", response['utterance'])
self.assertEqual("", response['response'])
def test_client_unknown(self):
telegram_bot = MockTelegramBot()
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
client._response = "Unknown Question"
message = MockMessage("test123", None)
update = MockUpdate(message)
client.message(telegram_bot, update)
self.assertEquals("test123", telegram_bot._chat_id)
self.assertEquals("Unknown Question", telegram_bot._text)
def test_client_message(self):
telegram_bot = MockTelegramBot()
arguments = MockArgumentParser()
client = MockTelegramBotClient(arguments)
self.assertIsNotNone(client)
client._response = "Hi there"
message = MockMessage("test123", "Hello")
update = MockUpdate(message)
client.message(telegram_bot, update)
self.assertEquals("test123", telegram_bot._chat_id)
self.assertEquals("Hi there", telegram_bot._text)
def test_kik_client_init(self):
arguments = MockArgumentParser()
client = MockKikBotClient(arguments,
kik_bot=MockKikApi(bot="test",
api_key="KEY"))
self.assertIsNotNone(client)
self.assertEqual("KIK_BOT_API_KEY", client._bot_api_key)
self.assertIsInstance(client.get_client_configuration(),
KikConfiguration)
self.assertEqual('ProgramY AIML2.0 Kik Client',
client.get_description())
self.assertIsInstance(client._kik_bot, KikApi)
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.assertEqual('ProgramY AIML2.0 Client', client.get_description())
self.assertEqual('XMPPUSERNAME', client._username)
self.assertEqual('XMPPPASSWORD', client._password)
self.assertEqual("Server", client._server)
self.assertEqual(8080, client._port)
self.assertFalse(client._render_callback())
self.assertIsInstance(client.renderer, TextRenderer)
def test_poll(self):
arguments = MockArgumentParser()
client = MockTwitterBotClient(arguments)
self.assertIsNotNone(client)
self.assertTrue(client.connect())
client._username = "******"
client._username_len = 9
client.configuration.client_configuration._use_direct_message = True
client.configuration.client_configuration._auto_follow = True
client.configuration.client_configuration._use_status = True
client.configuration.client_configuration._polling_interval = 0
client._poll(-1, -1)
def test_format_success_response(self):
arguments = MockArgumentParser()
client = SanicYadlanClient("yadlan", arguments)
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.body = b'{"userId": "1234567890"}'
userInfo = UserInfo(client, request)
response = client.format_success_response("1234567890", "Hello", "Hi", userInfo)
self.assertIsNotNone(response)
self.assertEqual("1234567890", response['userId'])
self.assertEqual("Hello", response['utterance'])
self.assertEqual("Hi", response['response'])
self.assertEqual("None", response['topic'])
def test_process_request_no_api_key(self):
arguments = MockArgumentParser()
client = MockSanicYadlanClient(arguments)
self.assertIsNotNone(client)
client.configuration.client_configuration._use_api_keys = True
request = unittest.mock.Mock()
request.args = {}
request.body = b'{"userId": "1234567890", "utterance": "Hello"}'
client.answer = "Hi"
response, status = client.process_request(request)
self.assertIsNotNone(response)
self.assertEqual(status, 401)
def test_parse_messages(self):
arguments = MockArgumentParser()
client = MockSlackBotClient(arguments)
client._starterbot_id = "U024BE7LH"
client.test_question = "Hi there"
events = []
events.append({"type": "message", "text": "<@U024BE7LH> Hello", "channel": "test"})
client.parse_messages(events)
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_init(self):
config = RestConfiguration("test")
self.assertIsNotNone(config)
handler = MockRestBasicAuthorizationHandler(config)
self.assertIsNotNone(handler)
handler.auth_token = "1234567890"
arguments = MockArgumentParser()
client = RestBotClient("testrest", arguments)
self.assertIsNotNone(client)
client.license_keys.add_key('BASIC_AUTH_TOKEN', "1234567890")
handler.initialise(client)
self.assertEquals("1234567890", handler._basic_auth_token)
def test_receive_message_valid_message(self):
arguments = MockArgumentParser()
client = MockKikBotClient(arguments,
kik_bot=MockKikApi(bot="test",
api_key="KEY"))
self.assertIsNotNone(client)
request = unittest.mock.Mock()
request.from_user = "******"
request.headers = MockHeaders("LKHLKJGKJHGKJHGKJHGHJK")
request.json = {"messages": [{"body": "Hello", "type": "text"}]}
response = client.receive_message(request)
self.assertIsNotNone(response)
self.assertEqual("200 OK", response.status)
def test_facebook_client_init(self):
arguments = MockArgumentParser()
client = TestFacebookBotClient(arguments)
self.assertIsNotNone(client)
self.assertEquals("FACEBOOK_VERIFY_TOKEN", client._verify_token)
self.assertEquals("FACEBOOK_ACCESS_TOKEN", client._access_token)
self.assertEquals("Facebook",
client.bot.brain.properties.property("env"))
self.assertIsInstance(client.get_client_configuration(),
FacebookConfiguration)
self.assertIsInstance(client._facebook_bot, Bot)
def test_api_keys(self):
arguments = MockArgumentParser()
client = RestBotClient("testrest", 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 + "api_keys.txt"
client.initialise()
self.assertEqual(3, len(client.api_keys.api_keys))
self.assertTrue(client.api_keys.is_apikey_valid("11111111"))
self.assertTrue(client.api_keys.is_apikey_valid("22222222"))
self.assertTrue(client.api_keys.is_apikey_valid("33333333"))
self.assertFalse(client.api_keys.is_apikey_valid("99999999"))
def test_empty_config_init(self):
arguments = MockArgumentParser()
client = MockBotClient(arguments)
configuration = unittest.mock.Mock()
configuration.configurations = []
configuration.bot_selector = "programy.clients.client.DefaultBotSelector"
factory = BotFactory(client, configuration)
self.assertIsNotNone(factory)
bot = factory.select_bot()
self.assertIsNone(bot)
def test_twitter_init(self):
arguments = MockArgumentParser()
client = MockTwitterBotClient(arguments)
self.assertIsNotNone(client.get_client_configuration())
self.assertIsInstance(client.get_client_configuration(), TwitterConfiguration)
self.assertEqual("ProgramY AIML2.0 Twitter Client", client.get_description())
self.assertEqual("username", client._username)
self.assertEqual(8, client._username_len)
self.assertEqual("consumer_key", client._consumer_key)
self.assertEqual("consumer_secret", client._consumer_secret)
self.assertEqual("access_token", client._access_token)
self.assertEqual("access_secret", client._access_token_secret)
def test_verify_api_key_usage(self):
arguments = MockArgumentParser()
client = RestBotClient("testrest", 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 + "api_keys.txt"
client.initialise()
request = MockRequest()
request.args['apikey'] = '11111111'
self.assertTrue(client.api_keys.verify_api_key_usage(request))
def test_viber_client_init(self):
arguments = MockArgumentParser()
client = MockViberBotClient(arguments)
self.assertIsNotNone(client)
self.assertEqual("VIBER_TOKEN", client._viber_token)
self.assertIsNotNone(client._viber_bot)
self.assertIsInstance(client.get_client_configuration(),
ViberConfiguration)
self.assertIsInstance(client._viber_bot, Api)
self.assertFalse(client._render_callback())
self.assertIsInstance(client.renderer, TextRenderer)
