def test_root_to_template(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add root node to template node")
def test_equivalent(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternTemplateNode(TemplateNode())
node3 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_multiple_templates(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternTemplateNode(TemplateNode())
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add template node to template node")
def test_multiple_templates(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternTemplateNode(TemplateNode())
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add template node to template node")
def test_root_to_template(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add root node to template node")
def test_template_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternTemplateNode(TemplateNode())
self.assertIsNone(node._template_node_exist(new_node1))
node.add_template(new_node1)
self.assertIsNotNone(node._template_node_exist(new_node1))
new_node2 = PatternTemplateNode(TemplateNode(), userid="testid2")
self.assertIsNotNone(node._template_node_exist(new_node2))
node.add_template(new_node2)
self.assertIsNotNone(node._template_node_exist(new_node2))
def test_dump_no_caller(self):
global str1
node = PatternNode()
self.assertIsNotNone(node)
node.add_child(PatternWordNode("test"))
node.add_child(PatternPriorityWordNode("pTest"))
node.add_child(PatternZeroOrMoreWildCardNode("^"))
node.add_child(PatternZeroOrMoreWildCardNode("#"))
node.add_child(PatternOneOrMoreWildCardNode("*"))
node.add_child(PatternOneOrMoreWildCardNode("_"))
node.add_child(PatternTemplateNode(TemplateNode()))
node.add_child(PatternSetNode({"name": "test"}, "testtext"))
node.add_child(PatternISetNode({"name": "test"}, "testtext"))
node.add_child(PatternBotNode({"name": "test"}, "testtext"))
node.add_child(PatternRegexNode({"name": ".*"}, "testtext"))
node.dump("", output_func1)
self.assertEquals(
"NODE [*] [P(1)^(1)#(1)C(5)_(1)*(1)To(0)Th(0)Te(1)] "
"PWORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[pTest] "
"ZEROORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[^] "
"ZEROORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[#] "
"ONEORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[_] "
"ONEORMORE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] wildcard=[*] "
"PTEMPLATE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)] "
"WORD [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] word=[test] "
"SET [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] name=[TESTTEXT] "
"ISET [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] words=[TESTTEXT] "
"BOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] property=[test] "
"REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[testtext]",
str1)
def test_list_matches_no_template(self):
global total_str
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=PatternTemplateNode(
TemplateWordNode("Hello")),
sentence="HELLO",
response="Hi there")
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
total_str = ""
context.list_matches(self._client_context,
output_func=collector,
include_template=False)
self.assertEquals(
"\tMatches... Asked: HELLO 1: Match=(Topic) Node=(ONEORMORE [*]) Matched=() "
"2: Match=(Word) Node=(WORD [Hi]) Matched=(Hi) "
"3: Match=(Word) Node=(WORD [There]) Matched=(There) "
"Match score 100.00", total_str)
def test_check_child_is_wildcard_hash(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
wildcard._0ormore_hash = PatternZeroOrMoreWildCardNode('#')
wildcard._0ormore_hash._template = PatternTemplateNode(TemplateNode())
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.tokenizer)
sentence = Sentence(self._client_context.brain.tokenizer,
"TEST SENTENCE")
match = wildcard.check_child_is_wildcard("", self._client_context,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.tokenizer)
sentence = Sentence(self._client_context.brain.tokenizer, "TEST")
match = wildcard.check_child_is_wildcard("", self._client_context,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
def test_match_context_depth(self):
context = MatchContext()
self.assertFalse(context.matched())
template = PatternTemplateNode(template=TemplateNode)
context.set_template(template)
self.assertEquals(template, context.template_node())
self.assertTrue(context.matched())
def test_match_context_depth(self):
context = MatchContext(max_search_depth=100, max_search_timeout=60, tokenizer=self._client_context.brain.tokenizer)
self.assertEqual(100, context.max_search_depth)
self.assertEqual(60, context.max_search_timeout)
self.assertFalse(context.matched())
template = PatternTemplateNode(template=TemplateNode)
context.set_template(template)
self.assertEqual(template, context.template_node())
self.assertTrue(context.matched())
def test_match_context_depth(self):
context = MatchContext(max_search_depth=100, max_search_timeout=60)
self.assertEquals(100, context.max_search_depth)
self.assertEquals(60, context.max_search_timeout)
self.assertFalse(context.matched())
template = PatternTemplateNode(template=TemplateNode)
context.set_template(template)
self.assertEquals(template, context.template_node())
self.assertTrue(context.matched())
def test_init(self):
node = PatternTemplateNode(TemplateNode())
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternTemplateNode(TemplateNode())))
self.assertEqual(node.to_string(), "PTEMPLATE [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)] ")
def test_remove_template_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternTemplateNode(TemplateNode())
node.add_child(child_node)
self.assertIsNotNone(node.template)
node._remove_node(child_node)
self.assertIsNone(node.template)
def test_to_string(self):
node1 = PatternTemplateNode(TemplateNode())
self.assertEqual(node1.to_string(verbose=False), "PTEMPLATE")
self.assertEqual(
node1.to_string(),
"PTEMPLATE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)]")
node2 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertEqual(node2.to_string(verbose=False), "PTEMPLATE")
self.assertEqual(
node2.to_string(),
"PTEMPLATE [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)]")
def test_to_xml(self):
node1 = PatternTemplateNode(TemplateNode())
self.assertEqual('<template></template>\n',
node1.to_xml(self._client_context))
self.assertEqual('<template userid="*"></template>\n',
node1.to_xml(self._client_context, include_user=True))
node2 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertEqual('<template></template>\n',
node2.to_xml(self._client_context))
self.assertEqual('<template userid="testid"></template>\n',
node2.to_xml(self._client_context, include_user=True))
def test_template_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_template())
node = PatternNode()
node.add_template(PatternTemplateNode(None))
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_template())
def test_equivalent(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternTemplateNode(TemplateNode())
node3 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_to_xml(self):
node1 = PatternTemplateNode(TemplateNode())
self.assertEqual('<template></template>\n', node1.to_xml(self._client_context))
self.assertEqual('<template userid="*"></template>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertEqual('<template></template>\n', node2.to_xml(self._client_context))
self.assertEqual('<template userid="testid"></template>\n', node2.to_xml(self._client_context, include_user=True))
def test_to_string(self):
node1 = PatternTemplateNode(TemplateNode())
self.assertEqual(node1.to_string(verbose=False), "PTEMPLATE")
self.assertEqual(node1.to_string(), "PTEMPLATE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)]")
node2 = PatternTemplateNode(TemplateNode(), userid="testid")
self.assertEqual(node2.to_string(verbose=False), "PTEMPLATE")
self.assertEqual(node2.to_string(), "PTEMPLATE [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)]")
def test_check_child_is_wildcard_star(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
wildcard._1ormore_star = PatternOneOrMoreWildCardNode('*')
wildcard._1ormore_star._template = PatternTemplateNode(TemplateNode())
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
sentence = Sentence(self._client_context, "TEST SENTENCE")
match = wildcard.check_child_is_wildcard("", self._client_context, context, sentence, 0, Match.WORD, 0)
self.assertIsNotNone(match)
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
sentence = Sentence(self._client_context, "TEST")
match = wildcard.check_child_is_wildcard("", self._client_context, context, sentence, 0, Match.WORD, 0)
self.assertIsNone(match)
def test_check_child_is_wildcard_arrow(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
wildcard._0ormore_arrow = PatternZeroOrMoreWildCardNode('^')
wildcard._0ormore_arrow._template = PatternTemplateNode(TemplateNode())
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
sentence = Sentence("TEST SENTENCE")
match = wildcard.check_child_is_wildcard("", self.bot, self.clientid, context, sentence, 0, Match.WORD, 0)
self.assertIsNotNone(match)
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
sentence = Sentence("TEST")
match = wildcard.check_child_is_wildcard("", self.bot, self.clientid, context, sentence, 0, Match.WORD, 0)
self.assertIsNotNone(match)
def test_dump_with_caller(self):
node = PatternNode()
self.assertIsNotNone(node)
node.add_child(PatternWordNode("test"))
node.add_child(PatternPriorityWordNode("pTest"))
node.add_child(PatternZeroOrMoreWildCardNode("^"))
node.add_child(PatternZeroOrMoreWildCardNode("#"))
node.add_child(PatternOneOrMoreWildCardNode("*"))
node.add_child(PatternOneOrMoreWildCardNode("_"))
node.add_child(PatternTemplateNode(TemplateNode()))
node.add_child(PatternSetNode({"name": "test"}, "testtext"))
node.add_child(PatternISetNode({"name": "test"}, "testtext"))
node.add_child(PatternBotNode({"name": "test"}, "testtext"))
node.add_child(PatternRegexNode({"name": ".*"}, "testtext"))
node.dump("", YLogger.debug)
def test_consume_out_of_words_with_template(self):
node = PatternNode()
self.assertIsNotNone(node)
node.add_template(PatternTemplateNode(TemplateNode()))
match_context = MatchContext(max_search_depth=100,
max_search_timeout=100)
words = Sentence(self._client_context)
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNotNone(result)
def test_to_json(self):
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=PatternTemplateNode(
TemplateWordNode("Hello")))
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
json_data = context.to_json()
self.assertIsNotNone(json_data)
self.assertEquals(json_data["max_search_depth"], 100)
self.assertEquals(json_data["max_search_timeout"], 60)
self.assertIsInstance(json_data["total_search_start"],
datetime.datetime)
self.assertEquals(3, len(json_data["matched_nodes"]))
self.assertEquals(
json_data["matched_nodes"][0], {
'multi_word': True,
'node': 'ONEORMORE [*]',
'type': 'Topic',
'wild_card': True,
'words': []
})
self.assertEquals(
json_data["matched_nodes"][1], {
'multi_word': False,
'node': 'WORD [Hi]',
'type': 'Word',
'wild_card': False,
'words': ["Hi"]
})
self.assertEquals(
json_data["matched_nodes"][2], {
'multi_word': False,
'node': 'WORD [There]',
'type': 'Word',
'wild_card': False,
'words': ["There"]
})
def test_consume_with_priority_mismatch(self):
node = PatternZeroOrMoreWildCardNode("^")
priority = PatternPriorityWordNode("$TEST")
node.add_child(priority)
priority.add_template((PatternTemplateNode(TemplateWordNode("word"))))
match_context = MatchContext(max_search_depth=100,
max_search_timeout=100)
words = Sentence(self._client_context, text="THIS $TEST2")
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNone(result)
def test_to_json(self):
topic = PatternOneOrMoreWildCardNode("*")
word1 = PatternWordNode("Hi")
word2 = PatternWordNode("There")
context = MatchContext(max_search_depth=100,
max_search_timeout=60,
template_node=PatternTemplateNode(
TemplateWordNode("Hello")))
context.add_match(Match(Match.TOPIC, topic, None))
context.add_match(Match(Match.WORD, word1, "Hi"))
context.add_match(Match(Match.WORD, word2, "There"))
sentence = Sentence(self._client_context,
"One Two Three",
matched_context=context)
json_data = sentence.to_json()
self.assertIsNotNone(json_data)
def test_check_child_is_wildcard_hash(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
wildcard._0ormore_hash = PatternZeroOrMoreWildCardNode('#')
wildcard._0ormore_hash._template = PatternTemplateNode(TemplateNode())
context = MatchContext()
sentence = Sentence("TEST SENTENCE")
match = wildcard.check_child_is_wildcard("", self.bot, self.clientid,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
context = MatchContext()
sentence = Sentence("TEST")
match = wildcard.check_child_is_wildcard("", self.bot, self.clientid,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
def add_template_to_node(self, template_graph_root, current_node):
template_node = PatternTemplateNode(template_graph_root)
current_node = current_node.add_child(template_node)
return current_node
def test_init(self):
node = PatternTemplateNode(TemplateNode())
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternTemplateNode(TemplateNode())))
self.assertEqual(
node.to_string(),
"PTEMPLATE [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)] ")
def test_pattern_to_template(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternWordNode('test')
node1.can_add(node2)
node1.add_child(node2)
self.assertEqual(node1.children[0], node2)
def test_init(self):
node = PatternTemplateNode(TemplateNode())
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertTrue(node.is_template())
self.assertFalse(node.is_that())
self.assertFalse(node.is_topic())
self.assertFalse(node.is_wildcard())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternTemplateNode(TemplateNode())))
self.assertEqual(node.to_string(), "PTEMPLATE [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)] ")
self.assertEqual(node.to_string(verbose=False), "PTEMPLATE")
self.assertEqual('<template></template>\n', node.to_xml(self.bot, self.clientid))
self.assertFalse(node.equivalent(PatternTopicNode()))
def test_wrong_to_template(self):
node1 = PatternTemplateNode(TemplateNode())
with self.assertRaises(ParserException) as raised:
node1.can_add(None)
self.assertEqual(str(raised.exception), "Empty node, cannot add")
def test_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assert_child_node_exists(node, PatternWordNode("word"),
PatternWordNode("word"))
self.assert_child_node_exists(node,
PatternPriorityWordNode("priority"),
PatternPriorityWordNode("priority"))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('_'),
PatternOneOrMoreWildCardNode('_'))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('*'),
PatternOneOrMoreWildCardNode('*'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('#'),
PatternZeroOrMoreWildCardNode('#'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('^'),
PatternZeroOrMoreWildCardNode('^'))
self.assert_child_node_exists(node, PatternSetNode({}, "setname"),
PatternSetNode([], "setname"))
self.assert_child_node_exists(node, PatternBotNode({}, "botname"),
PatternBotNode([], "botname"))
self.assert_child_node_exists(node, PatternISetNode({}, "word1 word2"),
PatternISetNode([], "word1 word2"))
self.assert_child_node_exists(
node, PatternRegexNode({"pattern": "^LEGION$"}, None),
PatternRegexNode({"pattern": "^LEGION$"}, None))
self.assert_child_node_exists(
node, PatternRegexNode({"template": "LEGION"}, None),
PatternRegexNode({"template": "LEGION"}, None))
topic1 = PatternTopicNode()
topic2 = PatternTopicNode()
self.assertIsNone(node._node_exists(topic1))
node.add_topic(topic1)
new_node = node._node_exists(topic1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
new_node = node.add_topic(topic2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
that1 = PatternThatNode()
that2 = PatternThatNode()
self.assertIsNone(node._node_exists(that1))
node.add_that(that1)
new_node = node._node_exists(that1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
new_node = node.add_that(that2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
template1 = PatternTemplateNode(None)
template2 = PatternTemplateNode(None)
self.assertIsNone(node._node_exists(template1))
node.add_template(template1)
new_node = node._node_exists(template1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
new_node = node.add_template(template2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
node.dump("")
self.assertEqual(
node.to_xml(None, None), """<priority word="priority"></priority>
<zerormore wildcard="^">
</zerormore>
<zerormore wildcard="#">
</zerormore>
<oneormore wildcard="_">
</oneormore>
<oneormore wildcard="*">
</oneormore>
<topic></topic>
<that></that>
<template></template>
<word word="word"></word>
<set name="SETNAME">
</set><bot property="botname">
</bot><iset words="WORD1 WORD2"></iset>
<regex pattern="^LEGION$"></regex>
<regex template="LEGION"></regex>
""")
def test_init(self):
node = PatternTemplateNode(TemplateNode())
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertTrue(node.is_template())
self.assertFalse(node.is_that())
self.assertFalse(node.is_topic())
self.assertFalse(node.is_wildcard())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternTemplateNode(TemplateNode())))
self.assertEqual(node.to_string(), "PTEMPLATE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(1)]")
self.assertEqual(node.to_string(verbose=False), "PTEMPLATE")
self.assertEqual('<template></template>\n', node.to_xml(self._client_context))
self.assertFalse(node.equivalent(PatternTopicNode()))
