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_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_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.assertEquals(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.assertEquals("Matched", root.resolve(self._client_context))
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_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_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_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_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_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_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_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_node_defaults(self):
root = TemplateNode()
node = TemplateUniqNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEquals("", result)
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(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_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_no_question(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
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_exception_handling(self):
root = TemplateNode()
node = MockTemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
root.append(node)
with self.assertRaises(Exception):
node.resolve_to_string(self._client_context)
self.assertEquals("", root.resolve(self._client_context))
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node1 = TemplateWordNode("Hello")
root.append(node1)
node2 =TemplateWordNode("World!")
root.append(node2)
self.assertEqual(len(root.children), 2)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual(resolved, "Hello World!")
node2.word = "Again!"
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual(resolved, "Hello Again!")
def test_node_no_sentences(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question()
conversation.record_dialog(question)
self._client_context.bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
def test_no_map_for_name_defaultmap_not_set(self):
self._client_context.brain.maps._maps['COLOURS'] = {'BLACK': 'WHITE'}
node = TemplateMapNode()
node.name = TemplateWordNode("UNKNOWN")
node.append(TemplateWordNode("BLACK"))
root = TemplateNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("", result)
def test_node_no_words(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateRestNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(root.resolve(self._client_context), "NIL")
def test_node_customformat_constructor(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateDateNode(date_format="%c")
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertRegex(root.resolve(self._client_context), TemplateDateNodeTests.DEFAULT_DATETIME_REGEX)
def test_node_customformat(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateDateNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertRegex(root.resolve(self.bot, self.clientid), TemplateDateNodeTests.DEFAULT_DATETIME_REGEX)
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateIdNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(root.resolve(None, "clientid"), "clientid")
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
root.append(TemplateWordNode("Hello"))
root.append(TemplateWordNode("World!"))
self.assertEqual(len(root.children), 2)
resolved = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(resolved)
self.assertEqual(resolved, "Hello World!")
def test_no_var_defaultmap_set(self):
self._client_context.brain.maps._maps['COLOURS'] = {'BLACK': 'WHITE'}
self._client_context.brain.properties.add_property('default-map', "test_value")
node = TemplateMapNode()
node.name = TemplateWordNode("COLOURS")
node.append(TemplateWordNode("UNKNOWN"))
root = TemplateNode()
root.append(node)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("test_value", result)
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
log = TemplateLogNode()
self.assertIsNotNone(log)
log.append(TemplateWordNode("Log Test"))
root.append(log)
self.assertEqual(1, len(root.children))
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual("", resolved)
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
oob = TemplateOOBNode()
root.append(oob)
oob.append(TemplateWordNode("hello"))
self.assertEqual(len(root.children), 1)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual("<oob>hello</oob>", resolved)
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateImplodeNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
node.append(TemplateWordNode("H e l l o W o r l d"))
self.assertEqual(root.resolve(self._client_context), "HelloWorld")
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_nluintent_invalid_index(self):
root = TemplateNode()
node = TemplateNluIntentNode()
node._intentName = TemplateWordNode("*")
node._itemName = TemplateWordNode("score")
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": [{"intent": "nlu_intent", "score": 0.9}], "slots": []}'
conversation.current_question().set_property("__SYSTEM_NLUDATA__",
nlu_result)
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("0.9", result)
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.bot, self.clientid)
self.assertIsNotNone(resolved)
self.assertOneOf(
resolved,
["Test1 Test3", "Test1 Test4", "Test2 Test3", "Test2 Test4"])
def test_node_saerver_mode(self):
root = TemplateNode()
self.assertIsNotNone(root)
error_log = TemplateLogNode()
self.assertIsNotNone(error_log)
error_log.level = "error"
error_log.append(TemplateWordNode("Error Log"))
warnig_log = TemplateLogNode()
self.assertIsNotNone(warnig_log)
warnig_log.level = "warnig"
warnig_log.append(TemplateWordNode("Warnig Log"))
info_log = TemplateLogNode()
self.assertIsNotNone(info_log)
info_log.level = "info"
info_log.append(TemplateWordNode("Info log"))
debug_log = TemplateLogNode()
self.assertIsNotNone(debug_log)
debug_log.level = "debug"
debug_log.append(TemplateWordNode("Debug Log"))
root.append(error_log)
root.append(warnig_log)
root.append(info_log)
root.append(debug_log)
self.assertEqual(4, len(root.children))
self._client_context._server_mode = True
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertEqual("", resolved)
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertEqual(4, len(conversation.logs))
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.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",
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_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_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_node_with_invalid_index(self):
root = TemplateNode()
node = TemplateSrNode()
root.append(node)
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)
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("", root.resolve(self._client_context))
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_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_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_node_with_star_with_none(self):
root = TemplateNode()
node = TemplateThatStarNode()
root.append(node)
conversation = Conversation("testid", self._bot)
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._bot.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._bot.brain.tokenizer)
context.add_match(Match(Match.THAT, match, None))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._bot, self._clientid))
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("testid", self.bot)
question = Question.create_from_text("Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
self.bot._conversations["testid"] = conversation
response = root.resolve(self.bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
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):
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", "VAL2", "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), '14')
def test_node(self):
test_bot = Bot(Brain(BrainConfiguration()), BotConfiguration())
topic_element = ET.fromstring('<topic>*</topic>')
that_element = ET.fromstring('<that>*</that>')
pattern_element = ET.fromstring("<pattern>hello world</pattern>")
test_bot.brain._aiml_parser.pattern_parser.add_pattern_to_graph(
pattern_element, topic_element, that_element, None)
test_bot.brain._sets_collection.add_set("testset",
["val1", "val2", "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.assertEquals(root.resolve(test_bot, "testid"), '5')
def test_node_no_conversation(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
self.assertEqual("", root.resolve(self._client_context))
def test_node_invalid_class(self):
root = TemplateNode()
node = TemplateExtensionNode()
node.path = "programytest.parser.template.node_tests.test_extension.MockExtensionOther"
root.append(node)
self.assertEqual(root.resolve(self._bot, self._clientid), "")
