def test_equivalent_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
node2 = PatternRegexNode({"template": "LEGION"}, "")
node3 = PatternRegexNode({"template": "LEGION"}, "", userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_equivalent_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$")
node3 = PatternRegexNode({}, "^LEGION$", userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_not_equals_template(self):
self._client_context.brain.regex_templates.add_regex(
"LEGION", re.compile("^LEGION$", re.IGNORECASE))
node1 = PatternRegexNode({"template": "OTHER"}, "")
match = node1.equals(self._client_context,
Sentence(self._client_context, 'LEGION'), 0)
self.assertIsNotNone(match)
self.assertFalse(match.matched)
def test_equals_template(self):
self._client_context.brain.regex_templates.add_regex(
"LEGION", re.compile("^LEGION$", re.IGNORECASE))
node1 = PatternRegexNode({"template": "LEGION"}, "")
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
node3 = PatternRegexNode({"template": "LEGION"}, "", userid="testid2")
match1 = node1.equals(
self._client_context,
Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match1)
self.assertTrue(match1.matched)
match2 = node2.equals(
self._client_context,
Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match2)
self.assertTrue(match2.matched)
match3 = node3.equals(
self._client_context,
Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match3)
self.assertFalse(match3.matched)
def test_to_string_form(self):
node1 = PatternRegexNode({"form": "今[はわ]何時"}, "")
self.assertEqual(node1.to_string(verbose=False), "REGEX form=[今[はわ]何時]")
self.assertEqual(node1.to_string(verbose=True), "REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] form=[今[はわ]何時]")
node2 = PatternRegexNode({"form": "今[はわ]何時"}, "", userid="testid")
self.assertEqual(node2.to_string(verbose=False), "REGEX form=[今[はわ]何時]")
self.assertEqual(node2.to_string(verbose=True), "REGEX [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] form=[今[はわ]何時]")
def test_to_xml_form(self):
node1 = PatternRegexNode({"form": "今[はわ]何時"}, "")
self.assertEqual('<regex form="今[はわ]何時"></regex>\n', node1.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="*" form="今[はわ]何時"></regex>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternRegexNode({"form": "今[はわ]何時"}, "", userid="testid")
self.assertEqual('<regex form="今[はわ]何時"></regex>\n', node2.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="testid" form="今[はわ]何時"></regex>\n', node2.to_xml(self._client_context, include_user=True))
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 test_to_xml_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
self.assertEqual('<regex template="LEGION"></regex>\n', node1.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="*" template="LEGION"></regex>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
self.assertEqual('<regex template="LEGION"></regex>\n', node2.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="testid" template="LEGION"></regex>\n', node2.to_xml(self._client_context, include_user=True))
def test_to_string_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
self.assertEqual(node1.to_string(verbose=False), "REGEX template=[LEGION]")
self.assertEqual(node1.to_string(verbose=True), "REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] template=[LEGION]")
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
self.assertEqual(node2.to_string(verbose=False), "REGEX template=[LEGION]")
self.assertEqual(node2.to_string(verbose=True), "REGEX [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] template=[LEGION]")
def test_to_string_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
self.assertEqual(node1.to_string(verbose=False), "REGEX pattern=[^LEGION$]")
self.assertEqual(node1.to_string(verbose=True), "REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[^LEGION$]")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
self.assertEqual(node2.to_string(verbose=False), "REGEX pattern=[^LEGION$]")
self.assertEqual(node2.to_string(verbose=True), "REGEX [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[^LEGION$]")
def test_to_xml_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
self.assertEqual('<regex pattern="^LEGION$"></regex>\n', node1.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="*" pattern="^LEGION$"></regex>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
self.assertEqual('<regex pattern="^LEGION$"></regex>\n', node2.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="testid" pattern="^LEGION$"></regex>\n', node2.to_xml(self._client_context, include_user=True))
def test_init_with_nothing(self):
with self.assertRaises(ParserException) as raised:
node = PatternRegexNode({}, "")
self.assertEqual(
str(raised.exception),
"Invalid regex node, neither pattern or template specified as attribute or text"
)
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_not_at_equivalent_at_template_level(self):
node1 = PatternRegexNode({}, "^LEGION$")
template1 = TemplateNode()
template1.append(TemplateWordNode("test1"))
node1.add_template(template1)
node2 = PatternRegexNode({}, "^LEGION$")
template2 = TemplateNode()
template2.append(TemplateWordNode("test2"))
node1.add_template(template2)
self.assertTrue(node1.equivalent(node2))
def test_remove_regex_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternRegexNode([], "test")
node.add_child(child_node)
self.assertEqual(1, len(node.children))
node._remove_node(child_node)
self.assertEqual(0, len(node.children))
def test_remove_regex_node(self):
node = PatternNode()
self.assertIsNotNone(node)
child_node = PatternRegexNode({"name": ".*"}, "testtext")
node.add_child(child_node)
self.assertTrue(node._regex_node_exist(child_node))
node._remove_node(child_node)
self.assertFalse(node._regex_node_exist(child_node))
def test_equals_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
node3 = PatternRegexNode({}, "^LEGION$", userid="testid2")
match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match1)
self.assertTrue(match1.matched)
match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match2)
self.assertTrue(match2.matched)
match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match3)
self.assertFalse(match3.matched)
def test_equivalent_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
node2 = PatternRegexNode({"template": "LEGION"}, "")
node3 = PatternRegexNode({"template": "LEGION"}, "", userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_equivalent_from(self):
node1 = PatternRegexNode({"form": "今[はわ]何時"}, "")
node2 = PatternRegexNode({"form": "今[はわ]何時"}, "")
node3 = PatternRegexNode({"form": "今[はわ]何時"}, "", userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_equivalent_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$")
node3 = PatternRegexNode({}, "^LEGION$", userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_to_string_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
self.assertEqual(node1.to_string(verbose=False), "REGEX template=[LEGION]")
self.assertEqual(node1.to_string(verbose=True), "REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] template=[LEGION]")
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
self.assertEqual(node2.to_string(verbose=False), "REGEX template=[LEGION]")
self.assertEqual(node2.to_string(verbose=True), "REGEX [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] template=[LEGION]")
def test_to_xml_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
self.assertEqual('<regex pattern="^LEGION$"></regex>\n', node1.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="*" pattern="^LEGION$"></regex>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
self.assertEqual('<regex pattern="^LEGION$"></regex>\n', node2.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="testid" pattern="^LEGION$"></regex>\n', node2.to_xml(self._client_context, include_user=True))
def test_to_xml_template(self):
node1 = PatternRegexNode({"template": "LEGION"}, "")
self.assertEqual('<regex template="LEGION"></regex>\n', node1.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="*" template="LEGION"></regex>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
self.assertEqual('<regex template="LEGION"></regex>\n', node2.to_xml(self._client_context, include_user=False))
self.assertEqual('<regex userid="testid" template="LEGION"></regex>\n', node2.to_xml(self._client_context, include_user=True))
def test_to_string_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
self.assertEqual(node1.to_string(verbose=False), "REGEX pattern=[^LEGION$]")
self.assertEqual(node1.to_string(verbose=True), "REGEX [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[^LEGION$]")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
self.assertEqual(node2.to_string(verbose=False), "REGEX pattern=[^LEGION$]")
self.assertEqual(node2.to_string(verbose=True), "REGEX [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] pattern=[^LEGION$]")
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_equivalent_mixed(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
node3 = PatternRegexNode({}, "^LEGION$", userid="testid2")
self._client_context.brain.regex_templates["LEGION"] = re.compile("^LEGION$", re.IGNORECASE)
node4 = PatternRegexNode({"template": "LEGION"}, "")
node5 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
node6 = PatternRegexNode({"template": "LEGION"}, "", userid="testid2")
self.assertFalse(node1.equivalent(node4))
self.assertFalse(node2.equivalent(node5))
self.assertFalse(node3.equivalent(node6))
def test_equals_pattern(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
node3 = PatternRegexNode({}, "^LEGION$", userid="testid2")
match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match1)
self.assertTrue(match1.matched)
match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match2)
self.assertTrue(match2.matched)
match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match3)
self.assertFalse(match3.matched)
def test_equals_template(self):
self._client_context.brain.regex_templates["LEGION"] = re.compile("^LEGION$", re.IGNORECASE)
node1 = PatternRegexNode({"template": "LEGION"}, "")
node2 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
node3 = PatternRegexNode({"template": "LEGION"}, "", userid="testid2")
match1 = node1.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match1)
self.assertTrue(match1.matched)
match2 = node2.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match2)
self.assertTrue(match2.matched)
match3 = node3.equals(self._client_context, Sentence(self._client_context.brain.tokenizer, 'LEGION'), 0)
self.assertIsNotNone(match3)
self.assertFalse(match3.matched)
def test_equivalent_at_pattern_template_missing_rhs(self):
node1 = PatternRegexNode({"template": "[A-Z]"}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$")
self.assertFalse(node1.equivalent(node2))
def test_init_template(self):
node = PatternRegexNode({"template": "LEGION"}, "")
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_regex())
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(PatternRegexNode({"template": "LEGION"}, "")))
def test_init_with_template_attrib(self):
node = PatternRegexNode({"template": "PhoneNumber"}, "")
self.assertIsNotNone(node)
self.assertIsNone(node._pattern_text)
self.assertEqual("PhoneNumber", node._pattern_template)
def test_equivalent_mixed(self):
node1 = PatternRegexNode({}, "^LEGION$")
node2 = PatternRegexNode({}, "^LEGION$", userid="testid")
node3 = PatternRegexNode({}, "^LEGION$", userid="testid2")
self._client_context.brain.regex_templates.add_regex("LEGION", re.compile("^LEGION$", re.IGNORECASE))
node4 = PatternRegexNode({"template": "LEGION"}, "")
node5 = PatternRegexNode({"template": "LEGION"}, "", userid="testid")
node6 = PatternRegexNode({"template": "LEGION"}, "", userid="testid2")
self.assertFalse(node1.equivalent(node4))
self.assertFalse(node2.equivalent(node5))
self.assertFalse(node3.equivalent(node6))
def test_init_with_pattern_attrib(self):
node = PatternRegexNode({"pattern": "^LEGION$"}, "")
self.assertIsNotNone(node)
self.assertIsNone(node._pattern_template)
self.assertEqual("^LEGION$", node._pattern_text)
def test_init_template(self):
node = PatternRegexNode({"template": "LEGION"}, "")
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_regex())
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(PatternRegexNode({"template": "LEGION"}, "")))
def test_init_template(self):
node = PatternRegexNode({"template": "LEGION"}, "")
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_regex())
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(PatternRegexNode({"template": "LEGION"}, "")))
self.assertEqual(
node.to_string(),
"REGEX [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)] template=[LEGION]"
)
self.assertEqual('<regex template="LEGION"></regex>\n',
node.to_xml(self._bot, self._clientid))
def test_init_with_form_attrib(self):
node = PatternRegexNode({"form": "今[はわ]何時"}, "")
self.assertIsNotNone(node)
self.assertIsNotNone(node._pattern_text)
self.assertTrue(node._is_form)
self.assertEqual("今[はわ]何時", node.pattern_text)
def test_init_with_nothing(self):
with self.assertRaises(ParserException) as raised:
PatternRegexNode({}, "")
self.assertEqual(str(raised.exception),
"No Parameter specified as attribute or text")
def test_init_with_invalid_attribs(self):
with self.assertRaises(ParserException) as raised:
PatternRegexNode({"unknwon": "test1"}, "")
self.assertEqual(str(raised.exception),
"No Parameter specified as attribute or text")
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_with_text(self):
node = PatternRegexNode({}, "^LEGION$")
self.assertIsNotNone(node)
self.assertIsNone(node._pattern_template)
self.assertFalse(node._is_form)
self.assertEqual("^LEGION$", node.pattern_text)
