def __init__(self, wildcard, userid='*'): PatternNode.__init__(self, userid) if wildcard not in self.matching_wildcards(): raise ParserException( "%s not in valid wildcards %s" % (wildcard, ", ".join(self.matching_wildcards()))) self._wildcard = wildcard
def __init__(self, attribs, text, userid='*'): PatternNode.__init__(self, userid) if 'name' in attribs: self._set_name = attribs['name'].upper() elif text: self._set_name = text.upper() else: raise ParserException( "Invalid set node, no name specified as attribute or text")
def can_add(self, new_node: PatternNode): if new_node.is_root(): raise ParserException("Cannot add root node to existing root node") if new_node.is_topic(): raise ParserException("Cannot add topic node to root node") if new_node.is_that(): raise ParserException("Cannot add that node to root node") if new_node.is_template(): raise ParserException("Cannot add template node to root node")
def test_priority_nodes(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.has_nodes()) self.assertFalse(node.has_priority_words()) node = PatternNode() node.add_child(PatternPriorityWordNode("pTest")) self.assertTrue(node.has_nodes()) self.assertTrue(node.has_priority_words())
def test_that_nodes(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.has_nodes()) self.assertFalse(node.has_that()) node = PatternNode() node.add_that(PatternThatNode()) self.assertFalse(node.has_nodes()) self.assertTrue(node.has_that())
def test_topic_nodes(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.has_nodes()) self.assertFalse(node.has_topic()) node = PatternNode() node.add_topic(PatternTopicNode()) self.assertFalse(node.has_nodes()) self.assertTrue(node.has_topic())
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 __init__(self, attribs, text, userid='*'): PatternNode.__init__(self, userid) if 'name' in attribs: self._property = attribs['name'] elif 'property' in attribs: self._property = attribs['property'] elif text: self._property = text else: raise ParserException( "Invalid bot node, neither name or property specified as attribute or text" )
def test_word_nodes(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.has_nodes()) node = PatternNode() node.add_child(PatternWordNode("test")) self.assertTrue(node.has_nodes()) self.assertTrue(node.has_children())
def test_regex_node_exists(self): node = PatternNode() self.assertIsNotNone(node) new_node1 = PatternRegexNode([], "test") self.assertIsNone(node._regex_node_exist(new_node1)) node.add_child(new_node1) self.assertIsNotNone(node._regex_node_exist(new_node1)) new_node2 = PatternRegexNode([], "test", userid="testid2") self.assertIsNone(node._regex_node_exist(new_node2)) node.add_child(new_node2) self.assertIsNotNone(node._regex_node_exist(new_node2))
def __init__(self, attribs, text, userid='*'): PatternNode.__init__(self, userid) self._words = [] if 'words' in attribs: words = attribs['words'].upper() elif text: words = text.upper() else: raise ParserException( "Invalid iset node, no words specified as attribute or text") self._parse_words(words) self._iset_name = "iset_%d" % (PatternISetNode.iset_count) PatternISetNode.iset_count += 1
def test_one_or_more_node_exists(self): node = PatternNode() self.assertIsNotNone(node) new_node1 = PatternOneOrMoreWildCardNode("*") self.assertIsNone(node._one_or_more_node_exist(new_node1)) node.add_child(new_node1) self.assertIsNotNone(node._one_or_more_node_exist(new_node1)) new_node2 = PatternOneOrMoreWildCardNode("*", userid="testid2") self.assertIsNone(node._one_or_more_node_exist(new_node2)) node.add_child(new_node2) self.assertIsNotNone(node._one_or_more_node_exist(new_node2))
def test_word_node_exists(self): node = PatternNode() self.assertIsNotNone(node) new_node1 = PatternWordNode("test") self.assertIsNone(node._word_node_exist(new_node1)) node.add_child(new_node1) self.assertIsNotNone(node._word_node_exist(new_node1)) new_node2 = PatternWordNode("test", userid="testid2") self.assertIsNone(node._word_node_exist(new_node2)) node.add_child(new_node2) self.assertIsNotNone(node._word_node_exist(new_node2))
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_that_node_exists(self): node = PatternNode() self.assertIsNotNone(node) new_node1 = PatternThatNode() self.assertIsNone(node._that_node_exist(new_node1)) node.add_that(new_node1) self.assertIsNotNone(node._that_node_exist(new_node1)) new_node2 = PatternThatNode(userid="testid2") self.assertIsNotNone(node._that_node_exist(new_node2)) node.add_that(new_node2) self.assertIsNotNone(node._that_node_exist(new_node2))
def __init__(self, attribs, text, userid='*'): PatternNode.__init__(self, userid) self._pattern_text = None self._pattern_template = None self._pattern = None if 'pattern' in attribs: self._pattern_text = attribs['pattern'] elif 'template' in attribs: self._pattern_template = attribs['template'] elif text: self._pattern_text = text else: raise ParserException("Invalid regex node, neither pattern or template specified as attribute or text") if self._pattern_text is not None: self._pattern = re.compile(self._pattern_text)
def test_init(self): node = PatternRootNode() self.assertIsNotNone(node) self.assertTrue(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.assertFalse(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(PatternRootNode())) self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]") node.add_child(PatternNode()) self.assertEqual(len(node.children), 1) self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)]")
def test_equals_ignore_case(self): node = PatternNode() self.assertIsNotNone(node) self.assertTrue(node.equals_ignore_case("", "")) self.assertTrue(node.equals_ignore_case("test", "test")) self.assertTrue(node.equals_ignore_case("Test", "test")) self.assertTrue(node.equals_ignore_case("test", "Test")) self.assertTrue(node.equals_ignore_case("TEST", "test")) self.assertTrue(node.equals_ignore_case("test", "TEST")) self.assertFalse(node.equals_ignore_case("test", "TESTX")) self.assertFalse(node.equals_ignore_case("testX", "TEST")) self.assertFalse(node.equals_ignore_case(None, "TEST")) self.assertFalse(node.equals_ignore_case("testX", None)) self.assertFalse(node.equals_ignore_case(None, None))
def test_nodes(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.has_nodes()) node = PatternNode() node._children.append(PatternNode()) self.assertTrue(node.has_nodes())
def test_add_child(self): node = PatternNode() self.assertIsNotNone(node) priority_word1 = PatternPriorityWordNode("pword") priority_word2 = PatternPriorityWordNode("pword") node.add_child(priority_word1) new_node = node.add_child(priority_word2) self.assertEqual(new_node, priority_word1) arrow_node1 = PatternZeroOrMoreWildCardNode("^") arrow_node2 = PatternZeroOrMoreWildCardNode("^") node.add_child(arrow_node1) new_node = node.add_child(arrow_node2) self.assertEqual(new_node, arrow_node1)
def test_remove_zeroormore_hash_node(self): node = PatternNode() self.assertIsNotNone(node) child_node = PatternZeroOrMoreWildCardNode("#") node.add_child(child_node) self.assertIsNotNone(node._0ormore_hash) node._remove_node(child_node) self.assertIsNone(node._0ormore_hash)
def test_remove_priority_node(self): node = PatternNode() self.assertIsNotNone(node) child_node = PatternPriorityWordNode("test") node.add_child(child_node) self.assertEquals(1, len(node.priority_words)) node._remove_node(child_node) self.assertEquals(0, len(node.priority_words))
def test_remove_oneormore_star_node(self): node = PatternNode() self.assertIsNotNone(node) child_node = PatternOneOrMoreWildCardNode("*") node.add_child(child_node) self.assertIsNotNone(node._1ormore_star) node._remove_node(child_node) self.assertIsNone(node._1ormore_star)
def test_get_tabs(self): node = PatternNode() self.assertIsNotNone(node) self._client_context.bot.configuration._tab_parse_output = True self.assertEquals("", node.get_tabs(self._client_context, 0)) self.assertEquals(" ", node.get_tabs(self._client_context, 1)) self.assertEquals(" ", node.get_tabs(self._client_context, 5)) self._client_context.bot.configuration._tab_parse_output = False self.assertEquals("", node.get_tabs(self._client_context, 0)) self.assertEquals("", node.get_tabs(self._client_context, 1)) self.assertEquals("", node.get_tabs(self._client_context, 5))
def test_remove_word_node(self): node = PatternNode() self.assertIsNotNone(node) child_node = PatternWordNode("test") node.add_child(child_node) self.assertEquals(1, len(node.children)) self.assertEquals(1, len(node._children_words)) node._remove_node(child_node) self.assertEquals(0, len(node.children)) self.assertEquals(0, len(node._children_words))
def equivalent(self, other: PatternNode)->bool: if other.is_root(): if self.userid == other.userid: return True return False
def __init__(self, template, userid='*'): PatternNode.__init__(self, userid) self._template = template
def test_init(self): node = PatternNode() self.assertIsNotNone(node) self.assertFalse(node.is_root()) self.assertEquals(0, len(node.priority_words)) self.assertFalse(node.has_priority_words()) self.assertFalse(node.is_priority()) self.assertIsNone(node.arrow) self.assertIsNone(node.hash) self.assertIsNone(node.underline) self.assertIsNone(node.star) self.assertFalse(node.has_wildcard()) self.assertFalse(node.has_zero_or_more()) self.assertFalse(node.has_0ormore_arrow()) self.assertFalse(node.has_0ormore_hash()) self.assertFalse(node.has_one_or_more()) self.assertFalse(node.has_1ormore_star()) self.assertFalse(node.has_1ormore_underline()) self.assertFalse(node.is_wildcard()) self.assertFalse(node.is_zero_or_more()) self.assertFalse(node.is_one_or_more()) self.assertEquals(0, len(node.children)) self.assertFalse(node.has_children()) self.assertFalse(node.has_nodes()) self.assertIsNone(node.topic) self.assertFalse(node.is_topic()) self.assertFalse(node.has_topic()) self.assertIsNone(node.that) self.assertFalse(node.is_that()) self.assertFalse(node.has_that()) self.assertIsNone(node.template) self.assertFalse(node.is_template()) self.assertFalse(node.has_template()) self.assertFalse(node.is_set()) self.assertFalse(node.is_bot()) self.assertEquals("P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)", node._child_count(verbose=True)) self.assertEquals("", node._child_count(verbose=False)) self.assertEquals("NODE [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]", node.to_string(verbose=True)) self.assertEquals("NODE", node.to_string(verbose=False)) self.assertEquals("", node.to_xml(self._client_context)) self.assertEquals("", node.to_xml(self._client_context))
def __init__(self, userid='*'): PatternNode.__init__(self, userid)
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) test_result = """<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> """ generated_xml = node.to_xml(self._client_context) self.assertEqual(generated_xml, test_result)