def test_xml_tree_simple(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateWordNode("Word2"))
xml = node.xml_tree(self._client_context)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template>Word1 Word2</template>", xml_str)
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.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", question.predicate("name"))
def test_nestedrandom(self):
root = TemplateNode()
self.assertIsNotNone(root)
random1 = TemplateRandomNode()
random1.append(TemplateWordNode("Test1"))
random1.append(TemplateWordNode("Test2"))
self.assertEqual(len(random1.children), 2)
random2 = TemplateRandomNode()
random2.append(TemplateWordNode("Test3"))
random2.append(TemplateWordNode("Test4"))
self.assertEqual(len(random1.children), 2)
random3 = TemplateRandomNode()
random3.append(random1)
random3.append(random1)
random3.append(random2)
root.append(random3)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertOneOf(resolved, ["Test1",
"Test2",
"Test3",
"Test4"])
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType3ConditionNode()
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(name="name1", value=TemplateWordNode("value1") )
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(name="name2", value=TemplateWordNode("value1"), local=True )
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(name="name3")
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
self.bot.conversation(self.clientid)._predicates['name1'] = "value1"
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("Word1", 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.bot._configuration.override_predicates = True
self.bot.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.bot.get_conversation(self.clientid)
self.assertIsNotNone(conversation)
question = Question.create_from_text("Hello")
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
result = node.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", conversation.predicate("name"))
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.brain.tokenizer, "Hello")
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 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)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you. Are you well")
question.current_sentence()._response = "Fine thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "")
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.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.brain.tokenizer, "Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
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.brain.tokenizer, "Hello")
conversation.record_dialog(question)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_carousel_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
carousel = TemplateCarouselNode()
card = TemplateCardNode()
card._image = TemplateWordNode("http://Servusai.com")
card._title = TemplateWordNode("Servusai.com")
card._subtitle = TemplateWordNode("The home of ProgramY")
button = TemplateButtonNode()
button._text = TemplateWordNode("More...")
button._url = TemplateWordNode("http://Servusai.com/aiml")
card._buttons.append(button)
carousel._cards.append(card)
root.append(carousel)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEquals("<carousel><card><image>http://Servusai.com</image><title>Servusai.com</title><subtitle>The home of ProgramY</subtitle><button><text>More...</text><url>http://Servusai.com/aiml</url></button></card></carousel>", resolved)
self.assertEquals("<carousel><card><image>http://Servusai.com</image><title>Servusai.com</title><subtitle>The home of ProgramY</subtitle><button><text>More...</text><url>http://Servusai.com/aiml</url></button></card></carousel>", root.to_xml(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)
conversation = Conversation(self._client_context)
self._client_context.bot._conversations["testid"] = conversation
question = Question.create_from_text(self._client_context.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation._questions.append(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "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_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.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "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._conversations["testid"] = conversation
self.assertEqual("Matched", node.resolve(self._client_context))
def test_node_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType2ConditionNode("var1", local=True)
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)
question = Question.create_from_text("Hello")
self.bot.conversation(self.clientid).record_dialog(question)
self.bot.conversation(self.clientid).current_question().set_predicate("var1", "value2")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
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.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("Hello matey", node.resolve(self._client_context))
def parse_bot_expression(self, expression, branch):
bot_node = TemplateBotNode()
branch.children.append(bot_node)
name_found = False
if 'name' in expression.attrib:
node = TemplateNode()
name_node = TemplateWordNode(expression.attrib['name'])
node.append(name_node)
name_found = True
bot_node.name = node
self.parse_text(self.get_text_from_element(expression), bot_node)
for child in expression:
if child.tag == 'name':
node = TemplateNode()
self.parse_text(self.get_text_from_element(child), node)
for sub_child in child:
self.parse_tag_expression(sub_child, node)
self.parse_text(self.get_text_from_element(child), node)
bot_node.name = node
name_found = True
else:
self.parse_tag_expression(child, bot_node)
self.parse_text(self.get_tail_from_element(child), bot_node)
if name_found is False:
raise ParserException("Error, name not found", xml_element=expression)
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation("testid", self.bot)
question = Question.create_from_text("Hello1 question")
question.current_sentence()._response = "Hello1 response"
conversation.record_dialog(question)
question = Question.create_from_text("Hello quesiton2")
question.current_sentence()._response = "Hello2 response"
conversation.record_dialog(question)
self.bot._conversations["testid"] = conversation
response = root.resolve(self.bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello1 response")
def test_node_exception_handling(self):
root = TemplateNode()
node = MockTemplateSentenceNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_node(self):
root = TemplateNode()
node = TemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_to_xml(self):
root = TemplateNode()
root.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template>Hello</template>", xml_str)
def test_node_defaults(self):
root = TemplateNode()
node = TemplateUniqNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_to_xml(self):
root = TemplateNode()
root.append(TemplateIdNode())
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><id /></template>", xml_str)
def test_node_exception_handling(self):
root = TemplateNode()
node = MockTemplateDeleteTripleNode(TemplateWordNode("S"), TemplateWordNode("P"), TemplateWordNode("O"))
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
def test_node_children(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
self.assertEqual(len(node.children), 1)
node.append(TemplateWordNode("Word2"))
self.assertEqual(len(node.children), 2)
self.assertEqual("Word1 Word2", node.resolve_children_to_string(self._client_context))
self.assertEqual("Word1 Word2", node.resolve(self._client_context))
self.assertEqual("[NODE]", node.to_string())
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateThatNode()
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><that /></template>", xml_str)
def test_to_xml_no_default_star(self):
root = TemplateNode()
node = TemplateThatNode(question=3, sentence=-1)
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><that index="3,*" /></template>', xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateDateNode()
root.append(node)
node.append(TemplateWordNode("Mon Sep 30 07:06:05 2013"))
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><date format="%c">Mon Sep 30 07:06:05 2013</date></template>', xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateRequestNode(index=3)
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><request index="3" /></template>', xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateResponseNode(position=2, index=3)
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><response index="3" position="2" /></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><addtriple><subj>S</subj><pred>P</pred><obj>O</obj></addtriple></template>", xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateResponseNode()
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><response /></template>", xml_str)
def test_olist_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
list = TemplateOrderedListNode()
list._items.append(TemplateWordNode("Item1"))
list._items.append(TemplateWordNode("Item2"))
root.append(list)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual("<olist><item>Item1</item><item>Item2</item></olist>",
resolved)
self.assertEqual("<olist><item>Item1</item><item>Item2</item></olist>",
root.to_xml(self._client_context))
def test_global_get_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 = False
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [Global] - [WORD]name]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property("default-get", "unknown")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_node_with_data(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateExtensionNode()
self.assertIsNotNone(node)
self.assertIsNone(node.path)
node.append(TemplateWordNode("Test"))
node.path = "programytest.parser.template.node_tests.test_extension.MockExtension"
self.assertEqual(
"programytest.parser.template.node_tests.test_extension.MockExtension",
node.path)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(root.resolve(self._bot, self._clientid), "Test")
def test_node_with_star(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation("testid", self.bot)
question = Question.create_from_text("Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text("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)
context.add_match(Match(Match.WORD, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self.bot._conversations["testid"] = conversation
self.assertEqual("Matched", root.resolve(self.bot, self.clientid))
def test_unknown_from_config(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.property_type = "name"
node.append(TemplateWordNode("Fred"))
self.assertIsNotNone(node)
self.assertEqual("[GET [name] - [WORD]name]", node.to_string())
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.bot.brain.configuration.defaults._default_get = None
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("unknown", result)
def test_node_CustomService(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSRAIXNode()
self.assertIsNotNone(node)
node.service = "api"
node._default = "unknown"
self.assertEqual("api", node.service)
root.append(node)
self.assertEqual(len(root.children), 1)
with self.assertRaises(Exception):
node.resolve_to_string(self._client_context)
self.assertEqual("[SRAIX (service=api, default=unknown)]",
node.to_string())
def test_node_years(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateIntervalNode()
self.assertEqual("[INTERVAL]", node.to_string())
node.interval_format = TemplateWordNode("%c")
node.style = TemplateWordNode("years")
node.interval_from = TemplateWordNode("Thu Oct 06 16:35:11 2014")
node.interval_to = TemplateWordNode("Fri Oct 07 16:35:11 2016")
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
response = root.resolve(self._client_context)
self.assertIsNotNone(response)
self.assertEqual(response, "2")
def test_url_button_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
button = TemplateButtonNode()
button._text = TemplateWordNode("Servusai.com")
button._url = TemplateWordNode("http://Servusai.com")
root.append(button)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual(
"<button><text>Servusai.com</text><url>http://Servusai.com</url></button>",
resolved)
self.assertEqual(
"<button><text>Servusai.com</text><url>http://Servusai.com</url></button>",
root.to_xml(self._client_context))
def test_url_postback_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
button = TemplateButtonNode()
button._text = TemplateWordNode("SAY HELLO")
button._postback = TemplateWordNode("HELLO")
root.append(button)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual(
"<button><text>SAY HELLO</text><postback>HELLO</postback></button>",
resolved)
self.assertEqual(
"<button><text>SAY HELLO</text><postback>HELLO</postback></button>",
root.to_xml(self._client_context))
def test_node(self):
topic_element = ET.fromstring('<topic>*</topic>')
that_element = ET.fromstring('<that>*</that>')
pattern_element = ET.fromstring("<pattern>hello world</pattern>")
self._client_context.brain._aiml_parser.pattern_parser.add_pattern_to_graph(pattern_element, topic_element, that_element, None)
self._client_context.brain.sets._sets["TESTSET"] = {"VAL1": ["VAL1"], "VAL2": ["VAL2"], "VAL3": ["VAL3"]}
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateVocabularyNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(root.resolve(self._client_context), '5')
def test_type2_to_xml_bot(self):
root = TemplateNode()
node = TemplateConditionNode("cond1", var_type=TemplateConditionNode.BOT, 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)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><condition bot="cond1"><li><value>value1</value>Word1</li> <li><value>value2</value>Word2</li> <li>Word3</li></condition></template>', xml_str)
def test_text_postback__replynode(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
reply = TemplateReplyNode()
reply._text = TemplateWordNode("SAY HELLO")
reply._postback = TemplateWordNode("HELLO")
root.append(reply)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual(
"<reply><text>SAY HELLO</text><postback>HELLO</postback></reply>",
resolved)
self.assertEqual(
"<reply><text>SAY HELLO</text><postback>HELLO</postback></reply>",
root.to_xml(self._client_context))
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateResponseNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation("testid", self.bot)
question = Question.create_from_text("Hello world")
question.current_sentence()._response = "Hello Matey"
conversation._questions.append(question)
self.bot._conversations["testid"] = conversation
response = root.resolve(self.bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello Matey")
def test_type3_to_xml(self):
root = TemplateNode()
node = TemplateConditionNode(condition_type=3)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(
name="name1",
value=TemplateWordNode("value1"),
var_type=TemplateConditionNode.GLOBAL)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(
name="name2",
value=TemplateWordNode("value1"),
var_type=TemplateConditionNode.LOCAL)
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(
name="name3",
value=TemplateWordNode("value3"),
var_type=TemplateConditionNode.BOT)
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
cond4 = TemplateConditionListItemNode(name="name4")
cond4.append(TemplateWordNode("Word4"))
node.append(cond4)
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
print(xml_str)
self.assertEqual(
'<template><condition><li name="name1"><value>value1</value>Word1</li> <li var="name2"><value>value1</value>Word2</li> <li bot="name3"><value>value3</value>Word3</li> <li name="name4">Word4</li></condition></template>',
xml_str)
def test_nluslot_invalid_index(self):
root = TemplateNode()
node = TemplateNluSlotNode()
node._slotName = TemplateWordNode("nlu_slot")
node._itemName = TemplateWordNode("entity")
node._index = TemplateWordNode("x")
self.assertIsNotNone(node)
root.append(node)
conversation = self._client_context.bot.get_conversation(
self._client_context)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
nlu_result = '{"intents": [], "slots": [{"slot": "nlu_slot", "entity": "value"}]}'
conversation.current_question().set_property("__SYSTEM_NLUDATA__",
nlu_result)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("value", result)
def test_call_PublishedBot_topic(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)
conversation = self._client_context.bot.get_conversation(
self._client_context)
conversation.set_property('topic', 'morning')
self.assertEqual("asked", node.resolve(self._client_context))
node._topic = TemplateWordNode("evening")
self.assertEqual("asked", node.resolve(self._client_context))
def test_tuples(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
select = TemplateSelectNode()
self.assertIsNotNone(select)
node = TemplateGetNode()
node.name = TemplateWordNode("?x ?y")
node.tuples = select
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual("[GET [Tuples] - ([WORD]?x ?y)]", node.to_string())
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><get var="?x ?y"><select /></get></template>', xml_str)
def test_multirandom(self):
root = TemplateNode()
self.assertIsNotNone(root)
random1 = TemplateRandomNode()
random1.append(TemplateWordNode("Test1"))
random1.append(TemplateWordNode("Test2"))
self.assertEqual(len(random1.children), 2)
random2 = TemplateRandomNode()
random2.append(TemplateWordNode("Test3"))
random2.append(TemplateWordNode("Test4"))
self.assertEqual(len(random1.children), 2)
root.append(random1)
root.append(random2)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertOneOf(
resolved,
["Test1 Test3", "Test1 Test4", "Test2 Test3", "Test2 Test4"])
def test_node_ymdhms(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateIntervalNode()
node.format = TemplateWordNode("%c")
node.style = TemplateWordNode("ymdhms")
node.interval_from = TemplateWordNode("Thu Jul 14 16:33:09 2014")
node.interval_to = TemplateWordNode("Fri Oct 7 16:35:11 2016")
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
response = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(response)
self.assertEqual(
response,
"2 years, 2 months, 23 days, 0 hours, 2 minutes, 2 seconds")
def test_save_learnf(self):
config = RedisStorageConfiguration()
engine = RedisStorageEngine(config)
engine.initialise()
store = RedisLearnfStore(engine)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
pattern = ET.Element('pattern')
pattern.text = "HELLO"
topic = ET.Element('topic')
topic.text = '*'
that = ET.Element('that')
that.text = '*'
template = TemplateNode()
template.append(TemplateWordNode("Hello"))
category = LearnCategory(pattern, topic, that, template)
is_replace = False
store.save_learnf(client_context, category, is_replace)
def test_resolve_with_defaults_inside_topic(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateTopicStarNode()
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, "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.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", root.resolve(self._client_context))
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 test_node_no_star(self):
root = TemplateNode()
node = TemplateThatStarNode()
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_to_xml_global(self):
root = TemplateNode()
node = TemplateType2ConditionNode("cond1")
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)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><condition name="cond1"><li><value>value1</value>Word1</li><li><value>value2</value>Word2</li><li>Word3</li></condition></template>',
xml_str)
def test_node_local_nomatch(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType1ConditionNode("var1",
TemplateWordNode("value1"),
local=True)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
question = Question.create_from_text("Hello")
self.bot.conversation(self.clientid).record_dialog(question)
self.bot.conversation(self.clientid).current_question().set_predicate(
"var1", "value2")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual(result, "")
def test_output_child(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateIdNode())
self.assertIsNotNone(node)
node.append(TemplateWordNode("Word1"))
node.output_child(node, "\t", "\n", print)
node.output_child(node, "\t", "\n", outputLog)
def test_type2_node_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("var1",
var_type=TemplateConditionNode.LOCAL,
condition_type=2)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(
value=TemplateWordNode("value1"),
var_type=TemplateConditionNode.LOCAL)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(
value=TemplateWordNode("value2"),
var_type=TemplateConditionNode.LOCAL)
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)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
self._bot.conversation(self._clientid).record_dialog(question)
self._bot.conversation(self._clientid).current_question().set_property(
"var1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def test_node(self):
if os.path.exists('/tmp/leanf.aiml'):
os.remove('/tmp/leanf.aiml')
root = TemplateNode()
self.assertIsNotNone(root)
learn = TemplateLearnfNode()
self.assertIsNotNone(learn)
learn_cat = LearnCategory(
ET.fromstring("<pattern>HELLO LEARN</pattern>"),
ET.fromstring("<topic>*</topic>"), ET.fromstring("<that>*</that>"),
TemplateWordNode("LEARN"))
learn.append(learn_cat)
root.append(learn)
self.assertEqual(1, len(root.children))
self.bot.brain.configuration.defaults._learn_filename = '/tmp/learnf.aiml'
resolved = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(resolved)
self.assertEqual("", resolved)
self.assertTrue(os.path.exists('/tmp/learnf.aiml'))
def test_type1_node_local_nomatch(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._bot.brain.tokenizer,
"Hello")
self._bot.conversation(self._clientid).record_dialog(question)
self._bot.conversation(self._clientid).current_question().set_property(
"var1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual(result, "")
def test_save_learnf(self):
config = FileStorageConfiguration()
tmpdir = os.path.dirname(__file__) + os.sep + "learnf"
config.learnf_storage._dirs = [tmpdir]
engine = FileStorageEngine(config)
engine.initialise()
store = FileLearnfStore(engine)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
learnf_path = store._get_storage_path()
learnf_fullpath = store.create_learnf_path(client_context, learnf_path)
if os.path.exists(learnf_fullpath):
os.remove(learnf_fullpath)
self.assertFalse(os.path.exists(learnf_fullpath))
pattern = ET.Element('pattern')
pattern.text = "HELLO"
topic = ET.Element('topic')
topic.text = '*'
that = ET.Element('that')
that.text = '*'
template = TemplateNode()
template.append(TemplateWordNode("Hello"))
category = LearnCategory(pattern, topic, that, template)
store.save_learnf(client_context, category)
self.assertTrue(os.path.exists(learnf_fullpath))
shutil.rmtree(tmpdir)
self.assertFalse(os.path.exists(tmpdir))
