anyconfig.tests.Test00Functions.test_12_create_from_namedtuple() - Code Metrics - Inspection of "enhancement: add test cases to create MergeableDic..." - ssato/python-anyconfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b5152d...f60cc8 )

by Satoru

created 2015-12-14 08:53 UTC

test_12_create_from_namedtuple() A

↳ Parent: anyconfig.tests.Test00Functions

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	12
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_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)

        self.assertTrue(isinstance(mobj, TT.MergeableDict))
        self.assertEquals(obj.name, mobj["name"])
        self.assertEquals(obj.a, mobj["a"])
        self.assertEquals(obj.b.b, mobj["b"]["b"])
        self.assertEquals(obj.b.c, mobj["b"]["c"])
        self.assertEquals(obj.e, mobj["e"])

    def test_20_get__invalid_inputs(self):
        dic = dict(a=1, b=[1, 2])
        (dic2, err) = TT.get(dic, '')
        self.assertEquals(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.assertEquals(TT.get(dic, "/foo")[0], ["bar", "baz"])
        self.assertEquals(TT.get(dic, "/foo/0")[0], "bar")
        self.assertEquals(TT.get(dic, "/")[0], 0)
        self.assertEquals(TT.get(dic, "/a~1b")[0], 1)
        self.assertEquals(TT.get(dic, "/c%d")[0], 2)
        self.assertEquals(TT.get(dic, "/e^f")[0], 3)
        self.assertEquals(TT.get(dic, "/g|h")[0], 4)
        self.assertEquals(TT.get(dic, r"/i\\j")[0], 5)
        self.assertEquals(TT.get(dic, r'/k\"l')[0], 6)
        self.assertEquals(TT.get(dic, "/ ")[0], 7)
        self.assertEquals(TT.get(dic, "/m~0n")[0], 8)

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

ssato / python-anyconfig

Push — master ( b5152d...f60cc8 )

test_12_create_from_namedtuple() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like