def test_pop_methods(self): client = TestClient() client_context = ClientContext(client, "testid") client_context.bot = Bot(BotConfiguration(), client) client_context.bot.configuration.conversations._max_histories = 3 client_context.brain = client_context.bot.brain conversation = Conversation(client_context) question1 = Question.create_from_text(client_context, "Hello There") conversation.record_dialog(question1) self.assertEquals(1, len(conversation.questions)) question2 = Question.create_from_text(client_context, "How are you") conversation.record_dialog(question2) self.assertEquals(2, len(conversation.questions)) conversation.pop_dialog() self.assertEquals(1, len(conversation.questions)) conversation.pop_dialog() self.assertEquals(0, len(conversation.questions)) conversation.pop_dialog() self.assertEquals(0, len(conversation.questions))
def test_node_with_star(self): root = TemplateNode() node = TemplateStarNode() root.append(node) conversation = Conversation(self._client_context) question = Question.create_from_text( self._client_context, "Hello world", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text( self._client_context, "How are you", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Very well thanks" conversation.record_dialog(question) match = PatternOneOrMoreWildCardNode("*") context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer) context.add_match(Match(Match.WORD, match, "Matched")) question.current_sentence()._matched_context = context conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation self.assertEqual("Matched", root.resolve(self._client_context))
def test_conversation_scores(self): conversation = Conversation(self.client_context) pos, sub = conversation.calculate_sentiment_score() self.assertEqual(0.0, pos) self.assertEqual(0.5, sub) question1 = Question.create_from_text(self.client_context, "Hello There") conversation.record_dialog(question1) pos, sub = conversation.calculate_sentiment_score() self.assertEqual(0.0, pos) self.assertEqual(0.0, sub) question2 = Question.create_from_text(self.client_context, "I really like you") conversation.record_dialog(question2) pos, sub = conversation.calculate_sentiment_score() self.assertEqual(0.1, pos) self.assertEqual(0.1, sub) question3 = Question.create_from_text(self.client_context, "Do you like me") conversation.record_dialog(question3) pos, sub = conversation.calculate_sentiment_score() self.assertEqual(0.06666666666666667, pos) self.assertEqual(0.06666666666666667, sub)
def test_resolve_to_string_three_digit(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateThatNode(index="1,1,3") self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertIsInstance(node.index, TemplateNode) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello world") question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "How are you") question.current_sentence()._response = "Very well thanks" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation self.assertEqual("", node.resolve(self._client_context))
def test_resolve_with_no_defaults(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateThatNode(question=1, sentence=1) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertEqual(1, node.question) self.assertEqual(1, node.sentence) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello world") question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "How are you") question.current_sentence()._response = "Very well thanks" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation self.assertEqual("Hello matey", node.resolve(self._client_context))
def test_resolve_no_sentence(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateRequestNode(index=3) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertEqual("3", node.index.word) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello world") question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "How are you. Are you well") question.current_sentence()._response = "Fine thanks" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation response = root.resolve(self._client_context) self.assertIsNotNone(response) self.assertEqual(response, "")
def test_resolve_no_defaults_inside_topic(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateTopicStarNode(index=1) self.assertIsNotNone(node) self.assertEqual(1, node.index) root.append(node) self.assertEqual(len(root.children), 1) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello world") question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "How are you") question.current_sentence()._response = "Very well thanks" conversation.record_dialog(question) match = PatternOneOrMoreWildCardNode("*") context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._client_context.brain.tokenizer) context.add_match(Match(Match.TOPIC, match, "Matched")) question.current_sentence()._matched_context = context conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations["testid"] = conversation self.assertEqual("Matched", node.resolve(self._client_context))
def test_resolve_with_no_defaults(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateRequestNode(index=1) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertEqual("1", node.index.word) conversation = Conversation(self._client_context) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation question = Question.create_from_text(self._client_context, "Hello world") question.current_sentence()._response = "Hello matey" conversation._questions.append(question) question = Question.create_from_text(self._client_context, "What did you say") question.current_sentence()._response = "Hello matey" conversation._questions.append(question) response = root.resolve(self._client_context) self.assertIsNotNone(response) self.assertEqual(response, "Hello world")
def test_resolve_no_sentence(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateInputNode(index=3) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertEqual(3, node.index) conversation = Conversation(self._client_context) question = Question.create_from_text( self._client_context, "Hello world", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text( self._client_context, "How are you. Are you well", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Fine thanks" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation with self.assertRaises(Exception): root.resolve(self._client_context)
def test_resolve_with_no_defaults(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateResponseNode(index=1) self.assertIsNotNone(node) self.assertIsInstance(node.index, TemplateNode) root.append(node) self.assertEqual(len(root.children), 1) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello1 question") question.current_sentence()._response = "Hello1 response" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "Hello quesiton2") question.current_sentence()._response = "Hello2 response" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation response = root.resolve(self._client_context) self.assertIsNotNone(response) self.assertEqual(response, "Hello1 response")
def get_question(self, client_context, pre_processed, srai): if srai is False: return Question.create_from_text(client_context, pre_processed, srai=srai) else: return Question.create_from_text(client_context, pre_processed, split=False, srai=srai)
def test_conversation(self): client = TestClient() client_context = ClientContext(client, "testid") client_context.bot = Bot(BotConfiguration(), client) client_context.bot.configuration.conversations._max_histories = 3 client_context.brain = client_context.bot.brain conversation = Conversation(client_context) self.assertIsNotNone(conversation) self.assertEqual(0, len(conversation._questions)) self.assertEqual(3, conversation._max_histories) self.assertEqual(1, len(conversation._properties)) with self.assertRaises(Exception): conversation.current_question() with self.assertRaises(Exception): conversation.previous_nth_question(0) question1 = Question.create_from_text(client_context, "Hello There") conversation.record_dialog(question1) self.assertEqual(question1, conversation.current_question()) with self.assertRaises(Exception): conversation.previous_nth_question(1) question2 = Question.create_from_text(client_context, "Hello There Again") conversation.record_dialog(question2) self.assertEqual(question2, conversation.current_question()) self.assertEqual(question1, conversation.previous_nth_question(1)) with self.assertRaises(Exception): conversation.previous_nth_question(3) question3 = Question.create_from_text(client_context, "Hello There Again Again") conversation.record_dialog(question3) self.assertEqual(question3, conversation.current_question()) self.assertEqual(question2, conversation.previous_nth_question(1)) with self.assertRaises(Exception): conversation.previous_nth_question(4) # Max Histories for this test is 3 # Therefore we should see the first question, pop of the stack question4 = Question.create_from_text(client_context, "Hello There Again Again Again") conversation.record_dialog(question4) self.assertEqual(question4, conversation.current_question()) self.assertEqual(question3, conversation.previous_nth_question(1)) with self.assertRaises(Exception): conversation.previous_nth_question(5)
def test_conversation_operations_multi_client_no_storage(self): config = BotConversationsConfiguration() config._multi_client = True mgr = ConversationManager(config) convo_dir = self.get_temp_dir() + os.sep + "storage" + os.sep + "conversations" if os.path.exists(convo_dir): shutil.rmtree(convo_dir) client = TestClient() #client.add_conversation_store(convo_dir) mgr.initialise(client.storage_factory) client_context = client.create_client_context("user1") conversation = mgr.get_conversation(client_context) question1 = Question.create_from_text(client_context, "Hello There") question1.sentence(0).response = "Hi" conversation.record_dialog(question1) mgr.save_conversation(client_context) question2 = Question.create_from_text(client_context, "Hello There Again") question2.sentence(0).response = "Hi Again" conversation.record_dialog(question2) mgr.save_conversation(client_context) question3 = Question.create_from_text(client_context, "Hello There Again Again") question3.sentence(0).response = "Hi Again Again" conversation.record_dialog(question3) mgr.save_conversation(client_context) conversation2 = mgr.get_conversation(client_context) self.assertIsNotNone(conversation2) self.assertEqual(len(mgr.conversations), 1) mgr.empty() self.assertEqual(len(mgr.conversations), 0) conversation = mgr.get_conversation(client_context) self.assertEqual(len(mgr.conversations), 1) if os.path.exists(convo_dir): shutil.rmtree(convo_dir) self.assertIsNotNone(conversation) self.assertEqual(len(conversation.questions), 0)
def test_node_no_star(self): root = TemplateNode() node = TemplateStarNode() root.append(node) conversation = Conversation(self._client_context) question = Question.create_from_text(self._client_context, "Hello world", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) question = Question.create_from_text(self._client_context, "How are you", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Very well thanks" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations["testid"] = conversation self.assertEqual("", root.resolve(self._client_context))
def test_type1_node_local_match(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateConditionNode("var1", TemplateWordNode("value1"), var_type=TemplateConditionNode.LOCAL) self.assertIsNotNone(node) node.append(TemplateWordNode("Hello")) root.append(node) self.assertEqual(len(root.children), 1) question = Question.create_from_text(self._client_context, "Hello") self._client_context.bot.get_conversation( self._client_context).record_dialog(question) self._client_context.bot.get_conversation( self._client_context).current_question().set_property( "var1", "value1") result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual(result, "Hello")
def test_equivalent_intent(self): nlu1 = PatternNluNode({"intent": "test"}, None) nlu2 = PatternNluNode({"intent": "test"}, None, userid="testid") nlu3 = PatternNluNode({"intent": "test"}, None, userid="testid2") 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) sentence = Sentence(self._client_context.brain.tokenizer, "YEMPTY") nlu_result = '{"intents": [{"intent": "test", "score": 0.9}], "slots": []}' conversation.current_question().set_property("__SYSTEM_NLUDATA__", nlu_result) self._client_context.match_nlu = True match1 = nlu1.equals(self._client_context, sentence, 0) self.assertIsNotNone(match1) self.assertTrue(match1.matched) match2 = nlu2.equals(self._client_context, sentence, 0) self.assertIsNotNone(match2) self.assertTrue(match2.matched) match3 = nlu3.equals(self._client_context, sentence, 0) self.assertIsNotNone(match3) self.assertFalse(match3.matched)
def test_nluslot_with_index_over(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateNluSlotNode() node._slotName = TemplateWordNode("*") node._itemName = TemplateWordNode("entity") node._index = TemplateWordNode("2") self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) 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()) nlu_result = '{"intents": [], "slots": [{"slot": "nlu_slot", "entity": "value1"}, {"slot": "nlu_slot", "entity": "value2"}]}' conversation.current_question().set_property("__SYSTEM_NLUDATA__", nlu_result) result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("unknown", result)
def test_type2_exception(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateConditionNode("cond1", condition_type=2) self.assertIsNotNone(node) cond1 = TemplateConditionListItemNode(value=TemplateWordNode("value1")) cond1.append(TemplateWordNode("Word1")) node.append(cond1) cond2 = TemplateConditionListItemNode(value=TemplateWordNode("value2")) cond2.append(TemplateWordNode("Word2")) node.append(cond2) cond3 = TemplateConditionListItemNode() cond3.append(TemplateWordNode("Word3")) node.append(cond3) root.append(node) self.assertEqual(len(root.children), 1) self._client_context.bot.get_conversation(self._client_context).set_property('cond1', "value2") question = Question.create_from_text(self._client_context, "Hello") self._client_context.bot.get_conversation(self._client_context).record_dialog(question) self._client_context.bot.get_conversation(self._client_context).current_question().set_property("cond1", "value2") result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("", result)
def test_global_set_allow_overrides_with_default(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) self._client_context.bot.configuration.override_propertys = True self._client_context.brain.properties.pairs.append(["name", "fred"]) node = TemplateSetNode() self.assertIsNotNone(node) node.name = TemplateWordNode("name") node.local = False node.append(TemplateWordNode("keith")) root.append(node) self.assertEqual(len(root.children), 1) conversation = self._client_context.bot.get_conversation(self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text(self._client_context, "Hello") conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) result = node.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("keith", result) self.assertEqual("keith", conversation.property("name"))
def test_local_set(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateSetNode() self.assertIsNotNone(node) node.name = TemplateWordNode("name") node.local = True node.append(TemplateWordNode("keith")) root.append(node) self.assertEqual(len(root.children), 1) conversation = self._client_context.bot.get_conversation(self._client_context) self.assertIsNotNone(conversation) question = Question.create_from_text(self._client_context, "Hello") conversation.record_dialog(question) self.assertIsNotNone(conversation.current_question()) result = node.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("keith", result) self.assertEqual("keith", question.property("name"))
def test_sentiment_feeling_last(self): extension = SentimentExtension() self.assertIsNotNone(extension) # Need to create a conversation first conversation = self.client_context.bot.get_conversation(self.client_context) question1 = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter) conversation.record_dialog(question1) question2 = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter) conversation.record_dialog(question2) conversation.recalculate_sentiment_score(self.client_context) result = extension.execute(self.client_context, "SENTIMENT FEELING LAST 1") self.assertIsNotNone(result) self.assertEqual("SENTIMENT FEELING NEUTRAL AND COMPLETELY OBJECTIVE", result)
def test_global_get(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateGetNode() node.name = TemplateWordNode("name") node.local = False node.append(TemplateWordNode("Fred")) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) 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()) conversation.set_property("name", "keith") result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("keith", result)
def assert_conversation_storage(self, store, can_empty=True, test_load=True): if can_empty is True: store.empty() client = TestClient() client_context = client.create_client_context("user1") conversation = Conversation(client_context) question1 = Question.create_from_text(client_context, "Hello There") question1.sentence(0).response = "Hi" conversation.record_dialog(question1) store.store_conversation(client_context, conversation) store.commit() if test_load is True: conversation2 = Conversation(client_context) store.load_conversation(client_context, conversation2) self.assertEqual(1, len(conversation2.questions)) self.assertEqual(1, len(conversation2.questions[0].sentences)) self.assertEqual("Hello There", conversation2.questions[0].sentences[0].text()) self.assertEqual("Hi", conversation2.questions[0].sentences[0].response)
def test_sentences_in_db(self): config = SQLStorageConfiguration() engine = SQLStorageEngine(config) engine.initialise() store = SQLConversationStore(engine) store.empty() client = TestClient() client_context = client.create_client_context("user1") question1 = Question.create_from_text(client_context, "Hello There") question1.sentence(0).response = "Hi" question1.sentence(0)._positivity = 0.5 question1.sentence(0)._subjectivity = 0.6 store._write_sentences_to_db(client_context, 1, question1) store.commit() question2 = Question() store._read_sentences_from_db(client_context, 1, question2) self.assertEqual(1, len(question2.sentences)) self.assertEqual(0.5, question2.sentences[0].positivity) self.assertEqual(0.6, question2.sentences[0].subjectivity) self.assertEqual(["Hello", "There"], question2.sentences[0].words) self.assertEqual("Hi", question2.sentences[0].response) store.empty()
def test_conversation_operations_no_conversation(self): config = BotConversationsConfiguration() mgr = ConversationManager(config) convo_dir = self.get_temp_dir() + os.sep + "storage" + os.sep + "conversations" if os.path.exists(convo_dir): shutil.rmtree(convo_dir) client = TestClient() client.add_conversation_store(convo_dir) mgr.initialise(client.storage_factory) client_context = client.create_client_context("user1") conversation = mgr.get_conversation(client_context) question1 = Question.create_from_text(client_context, "Hello There") question1.sentence(0).response = "Hi" conversation.record_dialog(question1) del mgr._conversations[client_context.userid] mgr.save_conversation(client_context)
def test_resolve_with_defaults(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateInputNode() self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self.assertEqual(0, node.index) conversation = Conversation(self._client_context) question = Question.create_from_text( self._client_context, "Hello world", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "Hello matey" conversation.record_dialog(question) self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation response = root.resolve(self._client_context) self.assertIsNotNone(response) self.assertEqual(response, "Hello world")
def test_attrib_with_html(self): template = ET.fromstring(""" <template> <a target="_new" href="http://www.google.com/search?q=<star />"> Google Search </a> </template> """) conversation = Conversation(self._client_context) question = Question.create_from_text( self._client_context, "GOOGLE AIML", self._client_context.bot.sentence_splitter) question.current_sentence()._response = "OK" conversation.record_dialog(question) match = PatternOneOrMoreWildCardNode("*") context = MatchContext(max_search_depth=100, max_search_timeout=-1) context.add_match(Match(Match.WORD, match, "AIML")) question.current_sentence()._matched_context = context self._client_context.bot._conversation_mgr._conversations[ "testid"] = conversation ast = self._graph.parse_template_expression(template) self.assertIsNotNone(ast) self.assertIsInstance(ast, TemplateNode) self.assertIsNotNone(ast.children) self.assertEqual(len(ast.children), 1) xml_node = ast.children[0] self.assertIsNotNone(xml_node) self.assertIsInstance(xml_node, TemplateXMLNode) attribs = xml_node.attribs self.assertEqual(2, len(attribs)) self.assertIsInstance(attribs['target'], TemplateWordNode) target = attribs['target'] self.assertEqual(len(target.children), 0) self.assertEqual("_new", target.word) self.assertIsInstance(attribs['href'], TemplateNode) href = attribs['href'] self.assertEqual(len(href.children), 3) self.assertIsInstance(href.children[0], TemplateWordNode) self.assertEqual('http://www.google.com/search?q=', href.children[0].word) self.assertIsInstance(href.children[1], TemplateNode) self.assertEqual(1, len(href.children[1].children)) star = href.children[1].children[0] self.assertIsInstance(star, TemplateStarNode) self.assertIsInstance(href.children[2], TemplateWordNode) self.assertEqual('', href.children[2].word) result = xml_node.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual( result, '<a target="_new" href="http://www.google.com/search?q=AIML">Google Search</a>' )
def test_nluintent_with_index(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateNluIntentNode() node._intentName = TemplateWordNode("nlu_intent") node._itemName = TemplateWordNode("score") node._index = TemplateWordNode("1") self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) 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()) nlu_result = '{"intents": [{"intent": "nlu_intent", "score": 0.9}, {"intent": "nlu_intent", "score": 0.75}], "slots": []}' conversation.current_question().set_property("__SYSTEM_NLUDATA__", nlu_result) result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("0.75", result)
def test_call_CustomService_response_default(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._default = "unknown" node.append(TemplateWordNode("Hello")) root.append(node) service = ServiceFactory.get_service("mock") service.set_response("") 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__.mock'))
def test_local_no_value(self): root = TemplateNode() self.assertIsNotNone(root) self.assertIsNotNone(root.children) self.assertEqual(len(root.children), 0) node = TemplateGetNode() node.name = TemplateWordNode("name") node.local = True node.append(TemplateWordNode("Fred")) self.assertIsNotNone(node) root.append(node) self.assertEqual(len(root.children), 1) self._client_context.brain.properties.add_property("default-get", "unknown") 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) result = root.resolve(self._client_context) self.assertIsNotNone(result) self.assertEqual("unknown", result)