Test_20.test_20_container_to_etree__child() - Code Metrics - Inspection of "refactor: rename some test classes" - ssato/python-anyconfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 11a6df...bffa60 )

by Satoru

created 2017-02-19 19:38 UTC

Test_20.test_20_container_to_etree__child() A

↳ Parent: Test_00

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	3	Features	0

Metric	Value
cc	1
dl	0
loc	5
rs	9.4285
c	3
b	3
f	0

#
# Copyright (C) 2012 - 2017 Satoru SATOH <ssato @ redhat.com>
# License: MIT
#
# pylint: disable=missing-docstring, invalid-name, protected-access
from __future__ import absolute_import
import os.path
import unittest

import anyconfig.backend.xml as TT
import anyconfig.backend.tests.ini
import anyconfig.tests.common
import anyconfig.compat

from anyconfig.tests.common import dicts_equal, to_bytes


XML_W_NS_S = """
<a xmlns="http://example.com/ns/config"
   xmlns:val="http://example.com/ns/config/val">
   <b>1</b>
   <val:c>C</val:c>
</a>
"""

CNF_0 = {'config': {'@attrs': {'name': 'foo'},
                    'a': '0',
                    'b': {'@attrs': {'id': 'b0'}, '@text': 'bbb'},
                    'c': None,
                    'sect0': {'d': 'x, y, z'},
                    'list1': [{'item': '0'}, {'item': '1'}, {'item': '2'}],
                    'list2': {'@attrs': {'id': 'list2'},
                              '@children': [{'item': 'i'},
                                            {'item': 'j'}]}}}
CNF_0_S = """\
<?xml version="1.0" encoding="UTF-8"?>
<config name='foo'>
  <a>0</a>
  <b id="b0">bbb</b>
  <c/>
  <sect0>
    <d>x, y, z</d>
  </sect0>
  <list1>
    <item>0</item>
    <item>1</item>
    <item>2</item>
  </list1>
  <list2 id="list2">
    <item>i</item>
    <item>j</item>
  </list2>
</config>
"""


class Test_00(unittest.TestCase):

    def test_10__namespaces_from_file(self):
        ref = {"http://example.com/ns/config": '',
               "http://example.com/ns/config/val": "val"}
        xmlfile = anyconfig.compat.StringIO(XML_W_NS_S)
        self.assertTrue(dicts_equal(TT._namespaces_from_file(xmlfile), ref))

    def test_20__process_elem_text__whitespaces(self):
        (elem, dic, subdic) = (TT.ET.XML("<a> </a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic)
        self.assertTrue(not dic)
        self.assertTrue(not subdic)

    def test_22__process_elem_text__wo_attrs_and_children(self):
        (elem, dic, subdic) = (TT.ET.XML("<a>A</a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic, text="#text")
        self.assertTrue(dicts_equal(dic, {"a": 'A'}))
        self.assertTrue(not subdic)

    def test_22__process_elem_text__wo_attrs_and_children_parse(self):
        (elem, dic, subdic) = (TT.ET.XML("<a>A</a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic, text="#text",
                              ac_parse_value=True)
        self.assertTrue(dicts_equal(dic, {"a": 'A'}))
        self.assertTrue(not subdic)

        (elem, dic, subdic) = (TT.ET.XML("<a>1</a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic, text="#text",
                              ac_parse_value=True)
        self.assertTrue(dicts_equal(dic, {"a": 1}))
        self.assertTrue(not subdic)

    def test_24__process_elem_text__w_attrs(self):
        (elem, dic, subdic) = (TT.ET.XML("<a id='1'>A</a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic, text="#text")
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"#text": 'A'}))

    def test_24__process_elem_text__w_children(self):
        (elem, dic, subdic) = (TT.ET.XML("<a>A<b/></a>"), {}, {})
        TT._process_elem_text(elem, dic, subdic, text="#text")
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"#text": 'A'}))

    def test_30__process_elem_attrs__wo_text_and_children(self):
        (elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic)
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))

    def test_32__process_elem_attrs__w_text(self):
        (elem, dic, subdic) = (TT.ET.XML("<a id='A'>AAA</a>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic)
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))

    def test_34__process_elem_attrs__merge_attrs(self):
        (elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic, merge_attrs=True)
        self.assertTrue(dicts_equal(dic, {"a": {"id": 'A'}}))
        self.assertTrue(not subdic)

    def test_36__process_elem_attrs__wo_text_and_children_parse(self):
        (elem, dic, subdic) = (TT.ET.XML("<a id='1'/>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 1}}))

        (elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))

        (elem, dic, subdic) = (TT.ET.XML("<a id='true'/>"), {}, {})
        TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": True}}))

    def test_40__process_children_elems__root(self):
        (elem, dic, subdic) = (TT.ET.XML("<list><i>A</i><i>B</i></list>"), {},
                               {})
        TT._process_children_elems(elem, dic, subdic)
        self.assertTrue(dicts_equal(dic, {"list": [{"i": "A"}, {"i": "B"}]}))
        self.assertTrue(not subdic)

    def test_42__process_children_elems__w_attr(self):
        (elem, dic) = (TT.ET.XML("<list id='xyz'><i>A</i><i>B</i></list>"), {})
        subdic = {"id": "xyz"}
        ref = subdic.copy()
        ref.update({"#children": [{"i": "A"}, {"i": "B"}]})

        TT._process_children_elems(elem, dic, subdic, children="#children")
        self.assertTrue(not dic)
        self.assertTrue(dicts_equal(subdic, ref), subdic)

    def test_44__process_children_elems__w_children_have_unique_keys(self):
        (elem, dic, subdic) = (TT.ET.XML("<a><x>X</x><y>Y</y></a>"), {}, {})
        TT._process_children_elems(elem, dic, subdic)
        self.assertTrue(dicts_equal(dic, {"a": {"x": "X", "y": "Y"}}))
        self.assertTrue(not subdic)

    def test_46__process_children_elems__w_merge_attrs(self):
        elem = TT.ET.XML("<a z='Z'><x>X</x><y>Y</y></a>")
        dic = {"a": {"@attrs": {"z": "Z"}}}
        subdic = dic["a"]["@attrs"]
        TT._process_children_elems(elem, dic, subdic, merge_attrs=True)
        self.assertTrue(dicts_equal(dic, {"a": {"x": "X", "y": "Y",
                                                "z": "Z"}}), dic)


def _xml_to_container(snippet, **opts):
    return TT.elem_to_container(TT.ET.XML(snippet), to_container=dict, **opts)


class Test_00_1(unittest.TestCase):

    def test_10_elem_to_container__None(self):
        self.assertEqual(TT.elem_to_container(None), dict())

    def test_10_root_to_container__None(self):
        self.assertEqual(TT.root_to_container(None), dict())

    def test_12_elem_to_container__empty(self):
        self.assertEqual(_xml_to_container("<a/>"), dict(a=None))

    def test_20_elem_to_container__attrs(self):
        ref = dict(a={"@attrs": dict(x='1', y='y')})
        self.assertEqual(_xml_to_container("<a x='1' y='y'/>"), ref)

    def test_30_elem_to_container__child(self):
        ref = dict(a=dict(b="b"))
        self.assertEqual(_xml_to_container("<a><b>b</b></a>"), ref)

    def test_32_elem_to_container__children__same_keys(self):
        ref = {'a': [{'b': '1'}, {'b': '2'}]}
        self.assertEqual(_xml_to_container("<a><b>1</b><b>2</b></a>"), ref)

    def test_34_elem_to_container__children(self):
        ref = {'a': {'b': 'b', 'c': 'c'}}
        self.assertEqual(_xml_to_container("<a><b>b</b><c>c</c></a>"), ref)

    def test_36_elem_to_container__children__same_keys_w_text(self):
        ref = {'a': {'@text': 'aaa', '@children': [{'b': '1'}, {'b': '2'}]}}
        self.assertEqual(_xml_to_container("<a>aaa<b>1</b><b>2</b></a>"), ref)

    def test_40_elem_to_container__text(self):
        self.assertEqual(_xml_to_container("<a>A</a>"), {'a': 'A'})

    def test_42_elem_to_container__text_attrs(self):
        ref = dict(a={"@attrs": {'x': 'X'}, "@text": "A"})
        self.assertEqual(_xml_to_container("<a x='X'>A</a>"), ref)

    def test_50_root_to_container__text_attrs_tags(self):
        ref = dict(a={"_attrs": {'x': 'X'}, "_text": "A"})
        tags = dict(attrs="_attrs", text="_text")
        self.assertEqual(TT.root_to_container(TT.ET.XML("<a x='X'>A</a>"),
                                              dict, {}, tags=tags),
                         ref)


def tree_to_string(tree):
    return TT.ET.tostring(tree.getroot())


class Test_00_2(unittest.TestCase):

    def test_00_container_to_etree__None(self):
        self.assertTrue(TT.container_to_etree(None) is None)

    def test_10_container_to_etree__text_attrs(self):
        ref = to_bytes('<a x="X" y="Y">A</a>')
        obj = dict(a={"@attrs": {'x': 'X', 'y': 'Y'}, "@text": "A"})
        res = TT.container_to_etree(obj)
        self.assertEqual(tree_to_string(res), ref)

    def test_12_container_to_etree__text_attrs_tags(self):
        ref = to_bytes('<a x="X" y="Y">A</a>')
        obj = dict(a={"_attrs": {'x': 'X', 'y': 'Y'}, "_text": "A"})
        tags = dict(attrs="_attrs", text="_text")
        res = TT.container_to_etree(obj, tags=tags)
        self.assertEqual(tree_to_string(res), ref)

    def test_20_container_to_etree__child(self):
        ref = to_bytes("<a><b>b</b></a>")
        obj = dict(a=dict(b="b"))
        res = TT.container_to_etree(obj)
        self.assertEqual(tree_to_string(res), ref)

    def test_22_container_to_etree__children(self):
        ref = to_bytes("<a><b>b</b><c>c</c></a>")
        obj = {'a': {'@children': [{'b': 'b'}, {'c': 'c'}]}}
        res = TT.container_to_etree(obj)
        self.assertEqual(tree_to_string(res), ref)


class Test10(anyconfig.backend.tests.ini.Test10):

    cnf = CNF_0
    cnf_s = CNF_0_S.encode("utf-8")
    load_options = dump_options = dict(ac_parse_value=False)

    def setUp(self):
        self.psr = TT.Parser()


class Test20(anyconfig.backend.tests.ini.Test20):

    psr_cls = TT.Parser
    cnf = CNF_0
    cnf_s = CNF_0_S
    cnf_fn = "conf0.xml"

    def setUp(self):
        self.psr = self.psr_cls()
        self.workdir = anyconfig.tests.common.setup_workdir()
        self.cpath = os.path.join(self.workdir, self.cnf_fn)
        with self.psr.wopen(self.cpath) as out:
            if anyconfig.compat.IS_PYTHON_3:
                out.write(self.cnf_s.encode("utf-8"))
            else:
                out.write(self.cnf_s)

    def test_12_load__w_options(self):
        cnf = self.psr.load(self.cpath, ac_parse_value=False)
        self._assert_dicts_equal(cnf)

    def test_22_dump__w_special_option(self):
        self.psr.dump(self.cnf, self.cpath, ac_parse_value=False)
        cnf = self.psr.load(self.cpath)
        self._assert_dicts_equal(cnf)

# vim:sw=4:ts=4:et:


1			#
2			# Copyright (C) 2012 - 2017 Satoru SATOH <ssato @ redhat.com>
3			# License: MIT
4			#
5			# pylint: disable=missing-docstring, invalid-name, protected-access
6			from __future__ import absolute_import
7			import os.path
8			import unittest
9
10			import anyconfig.backend.xml as TT
11			import anyconfig.backend.tests.ini
12			import anyconfig.tests.common
13			import anyconfig.compat
14
15			from anyconfig.tests.common import dicts_equal, to_bytes
16
17
18			XML_W_NS_S = """
19			<a xmlns="http://example.com/ns/config"
20			xmlns:val="http://example.com/ns/config/val">
21			<b>1</b>
22			<val:c>C</val:c>
23			</a>
24			"""
25
26			CNF_0 = {'config': {'@attrs': {'name': 'foo'},
27			'a': '0',
28			'b': {'@attrs': {'id': 'b0'}, '@text': 'bbb'},
29			'c': None,
30			'sect0': {'d': 'x, y, z'},
31			'list1': [{'item': '0'}, {'item': '1'}, {'item': '2'}],
32			'list2': {'@attrs': {'id': 'list2'},
33			'@children': [{'item': 'i'},
34			{'item': 'j'}]}}}
35			CNF_0_S = """\
36			<?xml version="1.0" encoding="UTF-8"?>
37			<config name='foo'>
38			<a>0</a>
39			<b id="b0">bbb</b>
40			<c/>
41			<sect0>
42			<d>x, y, z</d>
43			</sect0>
44			<list1>
45			<item>0</item>
46			<item>1</item>
47			<item>2</item>
48			</list1>
49			<list2 id="list2">
50			<item>i</item>
51			<item>j</item>
52			</list2>
53			</config>
54			"""
55
56
57			class Test_00(unittest.TestCase):
58
59			def test_10__namespaces_from_file(self):
60			ref = {"http://example.com/ns/config": '',
61			"http://example.com/ns/config/val": "val"}
62			xmlfile = anyconfig.compat.StringIO(XML_W_NS_S)
63			self.assertTrue(dicts_equal(TT._namespaces_from_file(xmlfile), ref))
64
65			def test_20__process_elem_text__whitespaces(self):
66			(elem, dic, subdic) = (TT.ET.XML("<a> </a>"), {}, {})
67			TT._process_elem_text(elem, dic, subdic)
68			self.assertTrue(not dic)
69			self.assertTrue(not subdic)
70
71			def test_22__process_elem_text__wo_attrs_and_children(self):
72			(elem, dic, subdic) = (TT.ET.XML("<a>A</a>"), {}, {})
73			TT._process_elem_text(elem, dic, subdic, text="#text")
74			self.assertTrue(dicts_equal(dic, {"a": 'A'}))
75			self.assertTrue(not subdic)
76
77			def test_22__process_elem_text__wo_attrs_and_children_parse(self):
78			(elem, dic, subdic) = (TT.ET.XML("<a>A</a>"), {}, {})
79			TT._process_elem_text(elem, dic, subdic, text="#text",
80			ac_parse_value=True)
81			self.assertTrue(dicts_equal(dic, {"a": 'A'}))
82			self.assertTrue(not subdic)
83
84			(elem, dic, subdic) = (TT.ET.XML("<a>1</a>"), {}, {})
85			TT._process_elem_text(elem, dic, subdic, text="#text",
86			ac_parse_value=True)
87			self.assertTrue(dicts_equal(dic, {"a": 1}))
88			self.assertTrue(not subdic)
89
90			def test_24__process_elem_text__w_attrs(self):
91			(elem, dic, subdic) = (TT.ET.XML("<a id='1'>A</a>"), {}, {})
92			TT._process_elem_text(elem, dic, subdic, text="#text")
93			self.assertTrue(not dic)
94			self.assertTrue(dicts_equal(subdic, {"#text": 'A'}))
95
96			def test_24__process_elem_text__w_children(self):
97			(elem, dic, subdic) = (TT.ET.XML("<a>A<b/></a>"), {}, {})
98			TT._process_elem_text(elem, dic, subdic, text="#text")
99			self.assertTrue(not dic)
100			self.assertTrue(dicts_equal(subdic, {"#text": 'A'}))
101
102			def test_30__process_elem_attrs__wo_text_and_children(self):
103			(elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
104			TT._process_elem_attrs(elem, dic, subdic)
105			self.assertTrue(not dic)
106			self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))
107
108			def test_32__process_elem_attrs__w_text(self):
109			(elem, dic, subdic) = (TT.ET.XML("<a id='A'>AAA</a>"), {}, {})
110			TT._process_elem_attrs(elem, dic, subdic)
111			self.assertTrue(not dic)
112			self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))
113
114			def test_34__process_elem_attrs__merge_attrs(self):
115			(elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
116			TT._process_elem_attrs(elem, dic, subdic, merge_attrs=True)
117			self.assertTrue(dicts_equal(dic, {"a": {"id": 'A'}}))
118			self.assertTrue(not subdic)
119
120			def test_36__process_elem_attrs__wo_text_and_children_parse(self):
121			(elem, dic, subdic) = (TT.ET.XML("<a id='1'/>"), {}, {})
122			TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
123			self.assertTrue(not dic)
124			self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 1}}))
125
126			(elem, dic, subdic) = (TT.ET.XML("<a id='A'/>"), {}, {})
127			TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
128			self.assertTrue(not dic)
129			self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": 'A'}}))
130
131			(elem, dic, subdic) = (TT.ET.XML("<a id='true'/>"), {}, {})
132			TT._process_elem_attrs(elem, dic, subdic, ac_parse_value=True)
133			self.assertTrue(not dic)
134			self.assertTrue(dicts_equal(subdic, {"@attrs": {"id": True}}))
135
136			def test_40__process_children_elems__root(self):
137			(elem, dic, subdic) = (TT.ET.XML("<list><i>A</i><i>B</i></list>"), {},
138			{})
139			TT._process_children_elems(elem, dic, subdic)
140			self.assertTrue(dicts_equal(dic, {"list": [{"i": "A"}, {"i": "B"}]}))
141			self.assertTrue(not subdic)
142
143			def test_42__process_children_elems__w_attr(self):
144			(elem, dic) = (TT.ET.XML("<list id='xyz'><i>A</i><i>B</i></list>"), {})
145			subdic = {"id": "xyz"}
146			ref = subdic.copy()
147			ref.update({"#children": [{"i": "A"}, {"i": "B"}]})
148
149			TT._process_children_elems(elem, dic, subdic, children="#children")
150			self.assertTrue(not dic)
151			self.assertTrue(dicts_equal(subdic, ref), subdic)
152
153			def test_44__process_children_elems__w_children_have_unique_keys(self):
154			(elem, dic, subdic) = (TT.ET.XML("<a><x>X</x><y>Y</y></a>"), {}, {})
155			TT._process_children_elems(elem, dic, subdic)
156			self.assertTrue(dicts_equal(dic, {"a": {"x": "X", "y": "Y"}}))
157			self.assertTrue(not subdic)
158
159			def test_46__process_children_elems__w_merge_attrs(self):
160			elem = TT.ET.XML("<a z='Z'><x>X</x><y>Y</y></a>")
161			dic = {"a": {"@attrs": {"z": "Z"}}}
162			subdic = dic["a"]["@attrs"]
163			TT._process_children_elems(elem, dic, subdic, merge_attrs=True)
164			self.assertTrue(dicts_equal(dic, {"a": {"x": "X", "y": "Y",
165			"z": "Z"}}), dic)
166
167
168			def _xml_to_container(snippet, **opts):
169			return TT.elem_to_container(TT.ET.XML(snippet), to_container=dict, **opts)
170
171
172			class Test_00_1(unittest.TestCase):
173
174			def test_10_elem_to_container__None(self):
175			self.assertEqual(TT.elem_to_container(None), dict())
176
177			def test_10_root_to_container__None(self):
178			self.assertEqual(TT.root_to_container(None), dict())
179
180			def test_12_elem_to_container__empty(self):
181			self.assertEqual(_xml_to_container("<a/>"), dict(a=None))
182
183			def test_20_elem_to_container__attrs(self):
184			ref = dict(a={"@attrs": dict(x='1', y='y')})
185			self.assertEqual(_xml_to_container("<a x='1' y='y'/>"), ref)
186
187			def test_30_elem_to_container__child(self):
188			ref = dict(a=dict(b="b"))
189			self.assertEqual(_xml_to_container("<a><b>b</b></a>"), ref)
190
191			def test_32_elem_to_container__children__same_keys(self):
192			ref = {'a': [{'b': '1'}, {'b': '2'}]}
193			self.assertEqual(_xml_to_container("<a><b>1</b><b>2</b></a>"), ref)
194
195			def test_34_elem_to_container__children(self):
196			ref = {'a': {'b': 'b', 'c': 'c'}}
197			self.assertEqual(_xml_to_container("<a><b>b</b><c>c</c></a>"), ref)
198
199			def test_36_elem_to_container__children__same_keys_w_text(self):
200			ref = {'a': {'@text': 'aaa', '@children': [{'b': '1'}, {'b': '2'}]}}
201			self.assertEqual(_xml_to_container("<a>aaa<b>1</b><b>2</b></a>"), ref)
202
203			def test_40_elem_to_container__text(self):
204			self.assertEqual(_xml_to_container("<a>A</a>"), {'a': 'A'})
205
206			def test_42_elem_to_container__text_attrs(self):
207			ref = dict(a={"@attrs": {'x': 'X'}, "@text": "A"})
208			self.assertEqual(_xml_to_container("<a x='X'>A</a>"), ref)
209
210			def test_50_root_to_container__text_attrs_tags(self):
211			ref = dict(a={"_attrs": {'x': 'X'}, "_text": "A"})
212			tags = dict(attrs="_attrs", text="_text")
213			self.assertEqual(TT.root_to_container(TT.ET.XML("<a x='X'>A</a>"),
214			dict, {}, tags=tags),
215			ref)
216
217
218			def tree_to_string(tree):
219			return TT.ET.tostring(tree.getroot())
220
221
222			class Test_00_2(unittest.TestCase):
223
224			def test_00_container_to_etree__None(self):
225			self.assertTrue(TT.container_to_etree(None) is None)
226
227			def test_10_container_to_etree__text_attrs(self):
228			ref = to_bytes('<a x="X" y="Y">A</a>')
229			obj = dict(a={"@attrs": {'x': 'X', 'y': 'Y'}, "@text": "A"})
230			res = TT.container_to_etree(obj)
231			self.assertEqual(tree_to_string(res), ref)
232
233			def test_12_container_to_etree__text_attrs_tags(self):
234			ref = to_bytes('<a x="X" y="Y">A</a>')
235			obj = dict(a={"_attrs": {'x': 'X', 'y': 'Y'}, "_text": "A"})
236			tags = dict(attrs="_attrs", text="_text")
237			res = TT.container_to_etree(obj, tags=tags)
238			self.assertEqual(tree_to_string(res), ref)
239
240			def test_20_container_to_etree__child(self):
241			ref = to_bytes("<a><b>b</b></a>")
242			obj = dict(a=dict(b="b"))
243			res = TT.container_to_etree(obj)
244			self.assertEqual(tree_to_string(res), ref)
245
246			def test_22_container_to_etree__children(self):
247			ref = to_bytes("<a><b>b</b><c>c</c></a>")
248			obj = {'a': {'@children': [{'b': 'b'}, {'c': 'c'}]}}
249			res = TT.container_to_etree(obj)
250			self.assertEqual(tree_to_string(res), ref)
251
252
253			class Test10(anyconfig.backend.tests.ini.Test10):
254
255			cnf = CNF_0
256			cnf_s = CNF_0_S.encode("utf-8")
257			load_options = dump_options = dict(ac_parse_value=False)
258
259			def setUp(self):
260			self.psr = TT.Parser()
261
262
263			class Test20(anyconfig.backend.tests.ini.Test20):
264
265			psr_cls = TT.Parser
266			cnf = CNF_0
267			cnf_s = CNF_0_S
268			cnf_fn = "conf0.xml"
269
270			def setUp(self):
271			self.psr = self.psr_cls()
272			self.workdir = anyconfig.tests.common.setup_workdir()
273			self.cpath = os.path.join(self.workdir, self.cnf_fn)
274			with self.psr.wopen(self.cpath) as out:
275			if anyconfig.compat.IS_PYTHON_3:
276			out.write(self.cnf_s.encode("utf-8"))
277			else:
278			out.write(self.cnf_s)
279
280			def test_12_load__w_options(self):
281			cnf = self.psr.load(self.cpath, ac_parse_value=False)
282			self._assert_dicts_equal(cnf)
283
284			def test_22_dump__w_special_option(self):
285			self.psr.dump(self.cnf, self.cpath, ac_parse_value=False)
286			cnf = self.psr.load(self.cpath)
287			self._assert_dicts_equal(cnf)
288
289			# vim:sw=4:ts=4:et:
290

ssato / python-anyconfig

Push — master ( 11a6df...bffa60 )

Test_20.test_20_container_to_etree__child() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like