def test_load_services(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
self.assertIsNotNone(ServiceFactory.get_service("mock"))
self.assertIsInstance(ServiceFactory.get_service("mock"), MockService)
def test_call_PublishedBot_response_default(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._userId = TemplateWordNode('1234567890')
node._default = "unknown"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response("")
self.set_collection_botnames()
self.assertEqual("unknown", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("unknown", node.resolve(self._client_context))
self.assertEqual("unknown",
question.property('__SUBAGENT_EXTBOT__.testbot'))
def test_call_GeneralRest_response_empty(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDREST__")
service.set_response("")
self.assertEqual("", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("", node.resolve(self._client_context))
def resolve_to_string(self, client_context):
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
if self._service is not None:
bot_service = ServiceFactory.get_service(self._service)
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self._service, response)
return response
else:
YLogger.error(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service)
return ""
def test_call_GeneralRest_response_none(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDREST__")
service.set_response(None)
self.assertIsNone(node.resolve(self._client_context))
def test_call_CustomService_response_none(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._service = "mock"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("mock")
service.set_response(None)
self.assertEqual(None, node.resolve(self._client_context))
def test_call_PublishedBot_response_none(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botId = "testBot"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response(None)
self.assertIsNone(node.resolve(self._client_context))
def resolve_to_string(self, bot, clientid):
resolved = self.resolve_children_to_string(bot, clientid)
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("[%s] resolved to [%s]", self.to_string(), resolved)
if self._service is not None:
bot_service = ServiceFactory.get_service(self._service)
response = bot_service.ask_question(bot, clientid, resolved)
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("SRAIX service [%s] return [%s]", self._service,
response)
return response
else:
if logging.getLogger().isEnabledFor(logging.ERROR):
logging.error(
"Sorry SRAIX does not currently have an implementation for [%s]",
self._service)
return ""
def test_call_PublishedBot(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._locale = TemplateWordNode('ja-JP')
node._time = TemplateWordNode('2019-01-01T00:00:00+09:00')
node._userId = TemplateWordNode('1234567890')
node._topic = TemplateWordNode('*')
node._deleteVariable = TemplateWordNode('false')
node._metadata = TemplateWordNode('1234567890')
node._config = TemplateWordNode('{"config":{"logLevel":"debug"}}')
node.append(TemplateWordNode("Hello"))
root.append(node)
self.set_collection_botnames()
self.assertEqual("asked", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response('{"response": "asked"}')
self.assertEqual("asked", node.resolve(self._client_context))
self.assertEqual('{"testbot": {"response": "asked"}}',
question.property('__SUBAGENT_EXTBOT__'))
def _published_Bot_interface(self, client_context):
self.locale = None
self.time = None
self.userId = None
self.topic = None
self.deleteVariable = None
self.metadata = None
self.config = None
conversation = client_context.bot.get_conversation(client_context)
if self._locale is not None:
self.locale = self._locale.resolve(client_context)
if self._time is not None:
self.time = self._time.resolve(client_context)
if self._userId is not None:
self.userId = self._userId.resolve(client_context)
if self._topic is not None:
self.topic = self._topic.resolve(client_context)
if self._topic is None or self.topic == '*':
if conversation.property('topic') is not '*':
self.topic = conversation.property('topic')
if self._deleteVariable is None:
self.deleteVariable = None
else:
self.deleteVariable = self._deleteVariable.resolve(client_context)
if self.deleteVariable.upper() == 'TRUE':
self.deleteVariable = True
else:
self.deleteVariable = False
if self._metadata is not None:
self.metadata = self._metadata.resolve(client_context)
if self._config is not None:
shift_text = self._config.resolve(client_context)
self.config = self._delete_shift_code(shift_text)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]",
self.to_string(), resolved)
bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_BOT)
bot_service.botId = self.botId
bot_service.botHost = self.botHost
bot_service.locale = self.locale
bot_service.time = self.time
bot_service.userId = self.userId
bot_service.topic = self.topic
bot_service.deleteVariable = self.deleteVariable
bot_service.metadata = self.metadata
bot_service.config = self.config
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX botid [%s] return [%s]",
self._botId, response)
status_code = ''
try:
status_code = bot_service.get_status_code()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property(
'__SUBAGENT_STATUS_CODE__', status_code)
if response is not None:
if conversation.has_current_question() is False:
if response == '' and self.default is not None:
response = self.default
else:
variableName = "__SUBAGENT_EXTBOT__"
if response != '':
try:
response_dic = json.loads(response)
save_dic = {self._botId: response_dic}
conversation.current_question().set_property(
variableName, json.dumps(save_dic))
response_data = response_dic['response']
if type(response_data) is dict:
response = json.dumps(response_data)
else:
response = response_data
except Exception:
if self.default is not None:
response = self.default
else:
response = ''
else:
if self.default is not None:
response = self.default
variableName += ".%s" % self._botId
conversation.current_question().set_property(
variableName, response)
return response
def _published_REST_interface(self, client_context):
self.host = None
self.method = None
self.query = None
self.header = None
self.body = None
if self._host is not None:
self.host = self._host.resolve(client_context)
if self._method is not None:
self.method = self._method.resolve(client_context)
if self._query is not None:
shift_text = self._query.resolve(client_context)
self.query = self._delete_shift_code(shift_text)
if self._header is not None:
shift_text = self._header.resolve(client_context)
self.header = self._delete_shift_code(shift_text)
if self._body is not None:
self.body = self._body.resolve(client_context)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]",
self.to_string(), resolved)
error_msg = None
if self._template is None:
exec_params = RestParameters(self.host)
if exec_params.host is None:
error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host
if error_msg is None and self.body is not None:
exec_params.set_body(self.body)
if error_msg is None and self.method is not None:
if exec_params.set_method(self.method) is False:
error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method
if error_msg is None and self.query is not None:
if exec_params.set_query(self.query) is False:
error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query
if error_msg is None and self.header is not None:
if exec_params.set_header(self.header) is False:
error_msg = "sraix subagent-rest : invalid locale parameter [%s]" % self.header
else:
restParams = client_context.brain.rest_templates.rest_template(
self._template)
if restParams is None:
error_msg = "sraix subagent-rest : REST-Template[%s] not found" % self._template
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
exec_params = copy.copy(restParams)
if self.host is not None:
if exec_params.change_host(self.host) is False:
error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host
if error_msg is None and self.body is not None:
exec_params.join_body(self.body)
if error_msg is None and self.method is not None:
if exec_params.set_method(self.method) is False:
error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method
if error_msg is None and self.query is not None:
if exec_params.join_query(self.query) is False:
error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query
if error_msg is None and self.header is not None:
if exec_params.join_header(self.header) is False:
error_msg = "sraix subagent-rest : invalid header parameter [%s]" % self.header
if error_msg is not None:
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
rest_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_REST)
rest_service.params = exec_params
if self._timeout is None:
timeout = self.SRAIX_DEFAULT_TIMEOUT
else:
timeout = self._timeout
response = rest_service.ask_question(client_context, resolved, timeout)
YLogger.debug(client_context, "SRAIX host [%s] return [%s]",
exec_params.host, response)
conversation = client_context.bot.get_conversation(client_context)
status_code = ''
latency = ''
try:
status_code = rest_service.get_status_code()
except NotImplementedError:
pass
try:
latency = rest_service.get_latency()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property(
'__SUBAGENT_STATUS_CODE__', status_code)
conversation.current_question().set_property(
'__SUBAGENT_LATENCY__', latency)
if response is not None:
if response == '' and self.default is not None:
response = self.default
variableName = "__SUBAGENT_BODY__"
if conversation.has_current_question() is True:
conversation.current_question().set_property(
variableName, response)
return response
