anyconfig.tests.Test00Functions.test_12_create_from__conver_to__namedtuple() - Code Metrics - Inspection of "refactor: reorder module imports; mock is not a st..." - ssato/python-anyconfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 940f1a...75e7b2 )

by Satoru

created 2015-12-16 06:33 UTC

test_12_create_from__conver_to__namedtuple() A

↳ Parent: anyconfig.tests.Test00Functions

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	17
rs	9.4286

#
# Copyright (C) 2011 - 2015 Satoru SATOH <ssato @ redhat.com>
#
# pylint: disable=missing-docstring,invalid-name
from __future__ import absolute_import

import collections
import unittest
import anyconfig.mergeabledict as TT

from anyconfig.tests.common import dicts_equal


class Test00Functions(unittest.TestCase):

    def test_10_create_from__convert_to(self):
        a = dict(name="a", a=1, b=dict(b=[1, 2], c="C"), e=[3, 4])
        b = TT.create_from(a)
        c = TT.convert_to(b)

        self.assertTrue(isinstance(b, TT.MergeableDict))
        self.assertTrue(isinstance(c, dict))
        self.assertFalse(isinstance(c, TT.MergeableDict))

    def test_12_create_from__conver_to__namedtuple(self):
        make_a = collections.namedtuple("A", "name a b e")
        make_b = collections.namedtuple("B", "b c")
        obj = make_a("foo", 1, make_b([1, 2], "C"), [3, 4])
        mobj = TT.create_from(obj)
        obj2 = TT.convert_to(mobj, to_namedtuple=True)

        self.assertTrue(isinstance(mobj, TT.MergeableDict))
        self.assertEqual(obj.name, mobj["name"])
        self.assertEqual(mobj[TT.NAMEDTUPLE_CLS_KEY], "A")
        self.assertEqual(obj.a, mobj["a"])
        self.assertEqual(mobj["b"][TT.NAMEDTUPLE_CLS_KEY], "B")
        self.assertEqual(obj.b.b, mobj["b"]["b"])
        self.assertEqual(obj.b.c, mobj["b"]["c"])
        self.assertEqual(obj.e, mobj["e"])

        self.assertEqual(obj, obj2)

    def test_20_get__invalid_inputs(self):
        dic = dict(a=1, b=[1, 2])
        (dic2, err) = TT.get(dic, '')
        self.assertEqual(err, '')
        self.assertTrue(dicts_equal(dic2, dic))

    def test_22_get__json_pointer(self):
        # test case in rfc, http://tools.ietf.org/html/rfc6901
        dic = {"foo": ["bar", "baz"],
               "": 0,
               "a/b": 1,
               "c%d": 2,
               "e^f": 3,
               "g|h": 4,
               r"i\\j": 5,
               r'k\"l': 6,
               " ": 7,
               "m~n": 8}

        self.assertTrue(dicts_equal(TT.get(dic, "")[0], dic))
        self.assertEqual(TT.get(dic, "/foo")[0], ["bar", "baz"])
        self.assertEqual(TT.get(dic, "/foo/0")[0], "bar")
        self.assertEqual(TT.get(dic, "/")[0], 0)
        self.assertEqual(TT.get(dic, "/a~1b")[0], 1)
        self.assertEqual(TT.get(dic, "/c%d")[0], 2)
        self.assertEqual(TT.get(dic, "/e^f")[0], 3)
        self.assertEqual(TT.get(dic, "/g|h")[0], 4)
        self.assertEqual(TT.get(dic, r"/i\\j")[0], 5)
        self.assertEqual(TT.get(dic, r'/k\"l')[0], 6)
        self.assertEqual(TT.get(dic, "/ ")[0], 7)
        self.assertEqual(TT.get(dic, "/m~0n")[0], 8)

    def test_24_get__json_pointer__array(self):
        dic = dict(a=[1, 2], )
        self.assertEqual(TT.get(dic, "/a/1"), (2, ''))

        (val, msg) = TT.get(dic, "/a/2")
        self.assertTrue(val is None)
        self.assertTrue(bool(msg))
        # maybe the error message depends on python version.
        # self.assertEqual(msg, 'list index out of range')

        (val, msg) = TT.get(dic, "/a/b/d/-")
        self.assertTrue(val is None)
        self.assertTrue(bool(msg))
        # Likewise.
        # self.assertEqual(msg, 'list indices must be integers...')


class Test10MergeableDict(unittest.TestCase):

    mk_mdict = TT.MergeableDict.create

    def test_20_update__w_replace(self):
        dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
        upd = self.mk_mdict(dict(a=2, b=dict(b=[3, 4, 5], d="D")))
        ref = TT.MergeableDict(**dic.copy())
        ref['a'] = 2
        ref['b'] = upd['b']
        ref['b']['c'] = dic['b']['c']

        dic.update(upd, TT.MS_REPLACE)
        self.assertTrue(dicts_equal(dic, ref))

    def test_22_update__w_replace__not_a_dict(self):
        dic = TT.MergeableDict()
        ref = TT.MergeableDict(**dic.copy())
        dic.update(1, TT.MS_REPLACE)
        self.assertTrue(dicts_equal(dic, ref))

    def test_24_update__w_None(self):
        dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
        ref = TT.MergeableDict(**dic.copy())
        dic.update(None)
        self.assertTrue(dicts_equal(dic, ref))

    def test_30_update__wo_replace(self):
        dic = self.mk_mdict(dict(a=1, b=dict(b=[1, 2], c="C")))
        upd = self.mk_mdict(dict(name="foo", a=2, b=dict(b=[3, 4, 5], d="D")))
        ref = TT.MergeableDict(**dic.copy())
        ref['name'] = upd['name']

        dic.update(upd, TT.MS_NO_REPLACE)
        self.assertTrue(dicts_equal(dic, ref))

    def test_40_update_w_merge__primitives(self):
        dic = self.mk_mdict(dict(a=1, b="b"))
        upd = self.mk_mdict(dict(a=2, b="B", c=[1, 2, 3]))
        dic2 = TT.MergeableDict(**dic.copy())
        ref = TT.MergeableDict(**dic.copy())
        ref["c"] = upd["c"]

        dic.update_w_merge(upd)
        self.assertTrue(dicts_equal(dic, upd))

        dic2.update_w_merge(upd, keep=True)
        self.assertTrue(dicts_equal(dic2, ref))

    def test_42_update_w_merge__lists(self):
        dic = TT.MergeableDict(a=[1, 2, 3])
        upd = TT.MergeableDict(a=[1, 4, 5])
        upd2 = TT.MergeableDict(a=1)
        dic2 = TT.MergeableDict(**dic.copy())
        ref = TT.MergeableDict(**dic.copy())
        ref["a"] = [1, 2, 3, 4, 5]

        dic.update_w_merge(upd)
        self.assertTrue(dicts_equal(dic, upd))

        dic2.update_w_merge(upd, merge_lists=True)
        self.assertTrue(dicts_equal(dic2, ref))

        dic2.update_w_merge(upd2, merge_lists=True, keep=True)
        self.assertTrue(dicts_equal(dic2, ref))

        dic2.update_w_merge(upd2, merge_lists=True, keep=False)
        self.assertTrue(dicts_equal(dic2, upd2))

    def test_48_update_w_merge_dicts__complex_case(self):
        dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C"),
                                 e=[3, 4]))
        upd = self.mk_mdict(dict(a=2, b=dict(b=[1, 2, 3], d="D")))
        ref = TT.MergeableDict(**dic.copy())
        ref['a'] = 2
        ref['b'] = TT.MergeableDict(b=[1, 2, 3], c="C", d="D")
        ref['e'] = [3, 4]

        dic.update_w_merge(upd)
        self.assertTrue(dicts_equal(dic, ref))

    def test_50_update__w_merge_dicts_and_lists(self):
        dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
        upd = self.mk_mdict(dict(a=2, b=dict(b=[3, 4], d="D", e=[1, 2])))

        ref = TT.MergeableDict(**dic.copy())
        ref['a'] = 2
        ref['b'] = TT.MergeableDict(b=[1, 2, 3, 4], c="C", d="D", e=[1, 2])

        dic.update(upd, TT.MS_DICTS_AND_LISTS)
        self.assertTrue(dicts_equal(dic, ref))

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


1			#
2			# Copyright (C) 2011 - 2015 Satoru SATOH <ssato @ redhat.com>
3			#
4			# pylint: disable=missing-docstring,invalid-name
5			from __future__ import absolute_import
6
7			import collections
8			import unittest
9			import anyconfig.mergeabledict as TT
10
11			from anyconfig.tests.common import dicts_equal
12
13
14			class Test00Functions(unittest.TestCase):
15
16			def test_10_create_from__convert_to(self):
17			a = dict(name="a", a=1, b=dict(b=[1, 2], c="C"), e=[3, 4])
18			b = TT.create_from(a)
19			c = TT.convert_to(b)
20
21			self.assertTrue(isinstance(b, TT.MergeableDict))
22			self.assertTrue(isinstance(c, dict))
23			self.assertFalse(isinstance(c, TT.MergeableDict))
24
25			def test_12_create_from__conver_to__namedtuple(self):
26			make_a = collections.namedtuple("A", "name a b e")
27			make_b = collections.namedtuple("B", "b c")
28			obj = make_a("foo", 1, make_b([1, 2], "C"), [3, 4])
29			mobj = TT.create_from(obj)
30			obj2 = TT.convert_to(mobj, to_namedtuple=True)
31
32			self.assertTrue(isinstance(mobj, TT.MergeableDict))
33			self.assertEqual(obj.name, mobj["name"])
34			self.assertEqual(mobj[TT.NAMEDTUPLE_CLS_KEY], "A")
35			self.assertEqual(obj.a, mobj["a"])
36			self.assertEqual(mobj["b"][TT.NAMEDTUPLE_CLS_KEY], "B")
37			self.assertEqual(obj.b.b, mobj["b"]["b"])
38			self.assertEqual(obj.b.c, mobj["b"]["c"])
39			self.assertEqual(obj.e, mobj["e"])
40
41			self.assertEqual(obj, obj2)
42
43			def test_20_get__invalid_inputs(self):
44			dic = dict(a=1, b=[1, 2])
45			(dic2, err) = TT.get(dic, '')
46			self.assertEqual(err, '')
47			self.assertTrue(dicts_equal(dic2, dic))
48
49			def test_22_get__json_pointer(self):
50			# test case in rfc, http://tools.ietf.org/html/rfc6901
51			dic = {"foo": ["bar", "baz"],
52			"": 0,
53			"a/b": 1,
54			"c%d": 2,
55			"e^f": 3,
56			"g\|h": 4,
57			r"i\\j": 5,
58			r'k\"l': 6,
59			" ": 7,
60			"m~n": 8}
61
62			self.assertTrue(dicts_equal(TT.get(dic, "")[0], dic))
63			self.assertEqual(TT.get(dic, "/foo")[0], ["bar", "baz"])
64			self.assertEqual(TT.get(dic, "/foo/0")[0], "bar")
65			self.assertEqual(TT.get(dic, "/")[0], 0)
66			self.assertEqual(TT.get(dic, "/a~1b")[0], 1)
67			self.assertEqual(TT.get(dic, "/c%d")[0], 2)
68			self.assertEqual(TT.get(dic, "/e^f")[0], 3)
69			self.assertEqual(TT.get(dic, "/g\|h")[0], 4)
70			self.assertEqual(TT.get(dic, r"/i\\j")[0], 5)
71			self.assertEqual(TT.get(dic, r'/k\"l')[0], 6)
72			self.assertEqual(TT.get(dic, "/ ")[0], 7)
73			self.assertEqual(TT.get(dic, "/m~0n")[0], 8)
74
75			def test_24_get__json_pointer__array(self):
76			dic = dict(a=[1, 2], )
77			self.assertEqual(TT.get(dic, "/a/1"), (2, ''))
78
79			(val, msg) = TT.get(dic, "/a/2")
80			self.assertTrue(val is None)
81			self.assertTrue(bool(msg))
82			# maybe the error message depends on python version.
83			# self.assertEqual(msg, 'list index out of range')
84
85			(val, msg) = TT.get(dic, "/a/b/d/-")
86			self.assertTrue(val is None)
87			self.assertTrue(bool(msg))
88			# Likewise.
89			# self.assertEqual(msg, 'list indices must be integers...')
90
91
92			class Test10MergeableDict(unittest.TestCase):
93
94			mk_mdict = TT.MergeableDict.create
95
96			def test_20_update__w_replace(self):
97			dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
98			upd = self.mk_mdict(dict(a=2, b=dict(b=[3, 4, 5], d="D")))
99			ref = TT.MergeableDict(**dic.copy())
100			ref['a'] = 2
101			ref['b'] = upd['b']
102			ref['b']['c'] = dic['b']['c']
103
104			dic.update(upd, TT.MS_REPLACE)
105			self.assertTrue(dicts_equal(dic, ref))
106
107			def test_22_update__w_replace__not_a_dict(self):
108			dic = TT.MergeableDict()
109			ref = TT.MergeableDict(**dic.copy())
110			dic.update(1, TT.MS_REPLACE)
111			self.assertTrue(dicts_equal(dic, ref))
112
113			def test_24_update__w_None(self):
114			dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
115			ref = TT.MergeableDict(**dic.copy())
116			dic.update(None)
117			self.assertTrue(dicts_equal(dic, ref))
118
119			def test_30_update__wo_replace(self):
120			dic = self.mk_mdict(dict(a=1, b=dict(b=[1, 2], c="C")))
121			upd = self.mk_mdict(dict(name="foo", a=2, b=dict(b=[3, 4, 5], d="D")))
122			ref = TT.MergeableDict(**dic.copy())
123			ref['name'] = upd['name']
124
125			dic.update(upd, TT.MS_NO_REPLACE)
126			self.assertTrue(dicts_equal(dic, ref))
127
128			def test_40_update_w_merge__primitives(self):
129			dic = self.mk_mdict(dict(a=1, b="b"))
130			upd = self.mk_mdict(dict(a=2, b="B", c=[1, 2, 3]))
131			dic2 = TT.MergeableDict(**dic.copy())
132			ref = TT.MergeableDict(**dic.copy())
133			ref["c"] = upd["c"]
134
135			dic.update_w_merge(upd)
136			self.assertTrue(dicts_equal(dic, upd))
137
138			dic2.update_w_merge(upd, keep=True)
139			self.assertTrue(dicts_equal(dic2, ref))
140
141			def test_42_update_w_merge__lists(self):
142			dic = TT.MergeableDict(a=[1, 2, 3])
143			upd = TT.MergeableDict(a=[1, 4, 5])
144			upd2 = TT.MergeableDict(a=1)
145			dic2 = TT.MergeableDict(**dic.copy())
146			ref = TT.MergeableDict(**dic.copy())
147			ref["a"] = [1, 2, 3, 4, 5]
148
149			dic.update_w_merge(upd)
150			self.assertTrue(dicts_equal(dic, upd))
151
152			dic2.update_w_merge(upd, merge_lists=True)
153			self.assertTrue(dicts_equal(dic2, ref))
154
155			dic2.update_w_merge(upd2, merge_lists=True, keep=True)
156			self.assertTrue(dicts_equal(dic2, ref))
157
158			dic2.update_w_merge(upd2, merge_lists=True, keep=False)
159			self.assertTrue(dicts_equal(dic2, upd2))
160
161			def test_48_update_w_merge_dicts__complex_case(self):
162			dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C"),
163			e=[3, 4]))
164			upd = self.mk_mdict(dict(a=2, b=dict(b=[1, 2, 3], d="D")))
165			ref = TT.MergeableDict(**dic.copy())
166			ref['a'] = 2
167			ref['b'] = TT.MergeableDict(b=[1, 2, 3], c="C", d="D")
168			ref['e'] = [3, 4]
169
170			dic.update_w_merge(upd)
171			self.assertTrue(dicts_equal(dic, ref))
172
173			def test_50_update__w_merge_dicts_and_lists(self):
174			dic = self.mk_mdict(dict(name="a", a=1, b=dict(b=[1, 2], c="C")))
175			upd = self.mk_mdict(dict(a=2, b=dict(b=[3, 4], d="D", e=[1, 2])))
176
177			ref = TT.MergeableDict(**dic.copy())
178			ref['a'] = 2
179			ref['b'] = TT.MergeableDict(b=[1, 2, 3, 4], c="C", d="D", e=[1, 2])
180
181			dic.update(upd, TT.MS_DICTS_AND_LISTS)
182			self.assertTrue(dicts_equal(dic, ref))
183
184			# vim:sw=4:ts=4:et:
185

ssato / python-anyconfig

Push — master ( 940f1a...75e7b2 )

test_12_create_from__conver_to__namedtuple() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like