def setUp(self):
"""
:return:
"""
a_dict = OrderedDict()
a_dict["an_other_key"] = "a value"
a_dict["a_key"] = 5
self.my_header = Header("some tag", a_dict)
def test_generate_xml_tree_from_list(self):
"""
:return:
"""
list_1 = [(0, "comment", Comment("a comment")),
(0, "header", Header("a header")), (0, "text", "some text"),
(0, "single_part_element", Element("an element"))]
test_1 = generate_xml_tree_from_list(list_1)
self.assertTrue(isinstance(test_1[0], list))
self.assertListEqual(test_1[0], list())
self.assertTrue(isinstance(test_1[1], list))
self.assertTrue(len(test_1[1]), 1)
self.assertTrue(test_1[1][0] == Element("an element"))
self.assertTrue(isinstance(test_1[2], list))
self.assertTrue(len(test_1[2]), 1)
self.assertTrue(test_1[2][0] == "some text")
self.assertTrue(isinstance(test_1[3], list))
self.assertTrue(len(test_1[3]), 1)
self.assertTrue(test_1[3][0] == Comment("a comment"))
self.assertTrue(isinstance(test_1[4], list))
self.assertTrue(len(test_1[4]), 1)
self.assertTrue(test_1[4][0] == Header("a header"))
list_2 = [(1, "start_two_parts_element", Element("an element")),
(1, "header", Header("a header")),
(0, "end_two_parts_element", None)]
with self.assertRaises(Exception):
generate_xml_tree_from_list(list_2, verbose=True)
list_3 = [(0, "start_two_parts_element", Element("a double element")),
(1, "single_part_element", Element("an element")),
(1, "comment", Comment("a comment")),
(1, "text", "some text"),
(1, "single_part_element", Element("an other element")),
(0, "end_two_parts_element", None)]
test_3 = generate_xml_tree_from_list(list_3)
rep_3 = Element("a double element")
rep_3.text = "some text"
rep_3.append(Element("an element"))
rep_3.append(Comment("a comment"))
rep_3.append(Element("an other element"))
self.assertTrue(isinstance(test_3[0], list))
self.assertListEqual(test_3[0], list())
self.assertTrue(isinstance(test_3[1], list))
self.assertTrue(len(test_3[1]), 1)
self.assertTrue(test_3[1][0] == rep_3)
self.assertTrue(isinstance(test_3[2], list))
self.assertListEqual(test_3[2], list())
self.assertTrue(isinstance(test_3[3], list))
self.assertListEqual(test_3[3], list())
self.assertTrue(isinstance(test_3[4], list))
self.assertListEqual(test_3[4], list())
def test_create_header(self):
"""
:return:
"""
a = Header("a tag")
self.assertEqual(a.level, 0)
self.assertEqual(a.tag, "a tag")
b = Header("an other tag", OrderedDict(my_attrib=["a value", 6]))
self.assertEqual(b.level, 0)
self.assertEqual(b.tag, "an other tag")
self.assertDictEqual(b.attrib, OrderedDict(my_attrib=["a value", 6]))
with self.assertRaises(TypeError):
Header()
def test_equality(self):
"""
:return:
"""
# Test __eq__
a_header = Header("some tag")
self.assertFalse(a_header == self.my_header)
a_header = Header("some tag", dict(a_key=4, an_other="a value"))
self.assertFalse(a_header == self.my_header)
a_dict = OrderedDict()
a_dict["an_other_key"] = "a value"
a_dict["a_key"] = 5
a_header.attrib = a_dict
self.assertTrue(a_header == self.my_header)
def test_parse_string_rewrite(self):
"""
:return:
"""
str_1 = "<? a_header ?>some introducing text<!-- a very long comment -->" \
"< a_tag> some text< an_other_beacon /></a_tag>"
rep_text_1 = "some introducing text"
rep_comments_1 = [
Comment("a very long comment"),
]
rep_headers_1 = Header("a_header")
rep_root_element_1 = Element("a_tag", text="some text")
rep_root_element_1.append(Element("an_other_beacon"))
test_1 = parse_xml_string_rewrite(str_1, verbose=True)
self.assertEqual(len(test_1), 4)
self.assertEqual(test_1[0], rep_text_1)
self.assertTrue(isinstance(test_1[1], list))
for (test, ref) in zip(test_1[1], rep_comments_1):
self.assertTrue(test == ref)
self.assertTrue(test_1[2] == rep_headers_1)
self.assertTrue(test_1[3] == rep_root_element_1)
str_2 = "<!-- a very long comment -->"
test_2 = parse_xml_string_rewrite(str_2)
self.assertEqual(len(test_2), 4)
self.assertEqual(test_2[0], "")
for (test, ref) in zip(test_2[1], rep_comments_1):
self.assertTrue(test == ref)
self.assertIsNone(test_2[2])
self.assertIsNone(test_2[3])
str_3 = "< a_tag> some text< an_other_beacon /></a_tag>< a_third_beacon />"
with self.assertRaises(Exception):
parse_xml_string_rewrite(str_3)
def test_correct_header(self):
"""
:return:
"""
str_1 = '<? xml encoding="utf-8"?> <my_beacon>a test value</my_beacon><-- a comment --><a_beacon/>'
str_2 = '<my_beacon>a test value</my_beacon><-- a comment --><a_beacon/>'
rep_str, rep_header = _find_xml_header(str_1)
self.assertEqual(rep_str, str_2)
self.assertTrue(rep_header == Header(
tag="xml", attrib=OrderedDict(encoding="utf-8")))
def test_representation(self):
"""
:return:
"""
# Test __str__ and __repr__
self.assertEqual(str(self.my_header),
'<?some tag an_other_key="a value" a_key="5"?>')
self.assertEqual(repr(self.my_header),
'<?some tag an_other_key="a value" a_key="5"?>')
an_other_header = Header("a tag")
self.assertEqual(str(an_other_header), "<?a tag?>")
self.assertEqual(repr(an_other_header), "<?a tag?>")
def setUp(self):
"""
:return:
"""
self.my_beacon = Beacon()
self.my_comment = Comment("A new comment !")
self.my_header = Header(
"A header", OrderedDict(an_attrib="a_value", an_other_attrib=6))
self.my_element = Element("An element",
text="A text",
attrib=OrderedDict(an_attrib="a_value",
an_other_attrib=6))
self.my_element.append(self.my_comment)
def test_representation(self):
"""
:return:
"""
# Test __str__ and __repr__
self.assertEqual(str(self.my_element),
'<some tag an_other_key="a value" a_key="5"/>')
self.assertEqual(repr(self.my_element),
'<some tag an_other_key="a value" a_key="5"/>')
an_other_header = Header("a tag")
self.assertEqual(
str(self.my_other_element),
'<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
'<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')
self.assertEqual(
repr(self.my_other_element),
'<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
'<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')
class TestsHeader(unittest.TestCase):
"""
"""
def setUp(self):
"""
:return:
"""
a_dict = OrderedDict()
a_dict["an_other_key"] = "a value"
a_dict["a_key"] = 5
self.my_header = Header("some tag", a_dict)
def test_create_header(self):
"""
:return:
"""
a = Header("a tag")
self.assertEqual(a.level, 0)
self.assertEqual(a.tag, "a tag")
b = Header("an other tag", OrderedDict(my_attrib=["a value", 6]))
self.assertEqual(b.level, 0)
self.assertEqual(b.tag, "an other tag")
self.assertDictEqual(b.attrib, OrderedDict(my_attrib=["a value", 6]))
with self.assertRaises(TypeError):
Header()
def test_equality(self):
"""
:return:
"""
# Test __eq__
a_header = Header("some tag")
self.assertFalse(a_header == self.my_header)
a_header = Header("some tag", dict(a_key=4, an_other="a value"))
self.assertFalse(a_header == self.my_header)
a_dict = OrderedDict()
a_dict["an_other_key"] = "a value"
a_dict["a_key"] = 5
a_header.attrib = a_dict
self.assertTrue(a_header == self.my_header)
def test_representation(self):
"""
:return:
"""
# Test __str__ and __repr__
self.assertEqual(str(self.my_header),
'<?some tag an_other_key="a value" a_key="5"?>')
self.assertEqual(repr(self.my_header),
'<?some tag an_other_key="a value" a_key="5"?>')
an_other_header = Header("a tag")
self.assertEqual(str(an_other_header), "<?a tag?>")
self.assertEqual(repr(an_other_header), "<?a tag?>")
def test_length(self):
"""
:return:
"""
# Test __len__
self.assertEqual(len(self.my_header), 45)
def test_dump(self):
"""
:return:
"""
# Test dump
self.assertEqual(self.my_header.dump(),
'<?some tag an_other_key="a value" a_key="5"?>')
def test_copy(self):
"""
:return:
"""
# Test __copy__
an_other_header = copy(self.my_header)
self.assertTrue(isinstance(an_other_header, Header))
self.assertEqual(an_other_header.level, self.my_header.level)
self.assertEqual(an_other_header.tag, self.my_header.tag)
self.assertDictEqual(an_other_header.attrib, self.my_header.attrib)
def test_dump_attrib(self):
"""
:return:
"""
# Test _dump_attrib
self.assertEqual(self.my_header._dump_attrib(),
'an_other_key="a value" a_key="5"')
self.assertEqual(self.my_header._dump_attrib(sort=True),
'a_key="5" an_other_key="a value"')
def test_find_next_element(self):
"""
:return:
"""
str_1 = '<? a_header key="value" ?><!--some comments--> '
rep_1 = find_next_element(str_1, level=5, verbose=True)
self.assertEqual(len(rep_1), 2)
self.assertEqual(rep_1[0], "<!--some comments-->")
self.assertTrue(isinstance(rep_1[1], tuple))
self.assertEqual(len(rep_1[1]), 3)
self.assertEqual(rep_1[1][0], 5)
self.assertEqual(rep_1[1][1], "header")
rep_elt_1 = Header("a_header", attrib=dict(key="value"))
self.assertTrue(rep_1[1][2] == rep_elt_1)
str_2 = " <!-- a comment with \" ' special characters < > --><? a header ?>"
rep_2 = find_next_element(str_2, tag="a_tag")
self.assertEqual(len(rep_2), 2)
self.assertEqual(rep_2[0], "<? a header ?>")
self.assertTrue(isinstance(rep_2[1], tuple))
self.assertEqual(len(rep_2[1]), 3)
self.assertEqual(rep_2[1][0], 0)
self.assertEqual(rep_2[1][1], "comment")
self.assertTrue(rep_2[1][2] == Comment(
"a comment with \" ' special characters < >"))
str_3 = "Some text with < special characters > to be skip < a_beacon/>"
rep_3 = find_next_element(str_3)
self.assertEqual(len(rep_3), 2)
self.assertEqual(rep_3[0], "< a_beacon/>")
self.assertTrue(isinstance(rep_3[1], tuple))
self.assertEqual(len(rep_3[1]), 3)
self.assertEqual(rep_3[1][0], 0)
self.assertEqual(rep_3[1][1], "text")
self.assertEqual(
rep_3[1][2],
"Some text with < special characters > to be skip")
str_4 = ' < a_beacon key1="5" key2="value2" />'
rep_4 = find_next_element(str_4)
self.assertEqual(len(rep_4), 2)
self.assertEqual(rep_4[0], "")
self.assertTrue(isinstance(rep_4[1], tuple))
self.assertEqual(len(rep_4[1]), 3)
self.assertEqual(rep_4[1][0], 0)
self.assertEqual(rep_4[1][1], "single_part_element")
rep_elt_4 = Element("a_beacon", attrib=OrderedDict(key1="5"))
rep_elt_4.attrib["key2"] = "value2"
self.assertTrue(rep_4[1][2] == rep_elt_4)
str_5 = ' < a_beacon key1="5" key2="value2" >'
rep_5 = find_next_element(str_5)
self.assertEqual(len(rep_5), 2)
self.assertEqual(rep_5[0], "")
self.assertTrue(isinstance(rep_5[1], tuple))
self.assertEqual(len(rep_5[1]), 3)
self.assertEqual(rep_5[1][0], 0)
self.assertEqual(rep_5[1][1], "start_two_parts_element")
rep_elt_5 = Element("a_beacon", attrib=OrderedDict(key1="5"))
rep_elt_5.attrib["key2"] = "value2"
self.assertTrue(rep_5[1][2] == rep_elt_5)
str_6 = ' </ a_beacon >'
rep_6 = find_next_element(str_6)
self.assertEqual(len(rep_6), 2)
self.assertEqual(rep_6[0], str_6.strip())
self.assertTrue(isinstance(rep_6[1], tuple))
self.assertEqual(len(rep_6[1]), 3)
self.assertEqual(rep_6[1][0], 0)
self.assertIsNone(rep_6[1][1])
self.assertIsNone(rep_6[1][2])
rep_7 = find_next_element(str_6, level=5)
self.assertEqual(len(rep_7), 2)
self.assertEqual(rep_7[0], str_6.strip())
self.assertTrue(isinstance(rep_7[1], tuple))
self.assertEqual(len(rep_7[1]), 3)
self.assertEqual(rep_7[1][0], 5)
self.assertIsNone(rep_7[1][1])
self.assertIsNone(rep_7[1][2])
rep_8 = find_next_element(str_6, tag="a_beacon")
self.assertEqual(len(rep_8), 2)
self.assertEqual(rep_8[0], str_6.strip())
self.assertTrue(isinstance(rep_8[1], tuple))
self.assertEqual(len(rep_8[1]), 3)
self.assertEqual(rep_8[1][0], 0)
self.assertIsNone(rep_8[1][1])
self.assertIsNone(rep_8[1][2])
rep_9 = find_next_element(str_6, level=5, tag="a_beacon")
self.assertEqual(len(rep_9), 2)
self.assertEqual(rep_9[0], "")
self.assertTrue(isinstance(rep_9[1], tuple))
self.assertEqual(len(rep_9[1]), 3)
self.assertEqual(rep_9[1][0], 4)
self.assertEqual(rep_9[1][1], "end_two_parts_element")
self.assertIsNone(rep_9[1][2])
str_10 = "<!-- toto"
rep_10 = find_next_element(str_10)
self.assertEqual(len(rep_10), 2)
self.assertEqual(rep_10[0], str_10)
self.assertTrue(isinstance(rep_10[1], tuple))
self.assertEqual(len(rep_10[1]), 3)
self.assertEqual(rep_10[1][0], 0)
self.assertIsNone(rep_10[1][1])
self.assertIsNone(rep_10[1][2])
str_11 = "<!-- tag"
rep_11 = find_next_element(str_11, tag="a_beacon", level=6)
self.assertEqual(len(rep_11), 2)
self.assertEqual(rep_11[0], str_11)
self.assertTrue(isinstance(rep_11[1], tuple))
self.assertEqual(len(rep_11[1]), 3)
self.assertEqual(rep_11[1][0], 6)
self.assertIsNone(rep_11[1][1])
self.assertIsNone(rep_11[1][2])