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()))