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)
