TestNestedOnce.test_append_triggers_save() - Code Metrics - Inspection of "Align mapper terms" - jacebrowning/yorm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#117)

by Jace

created 2016-04-13 14:02 UTC

TestNestedOnce.test_append_triggers_save() A

↳ Parent: TestNestedOnce

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	2
dl	0
loc	14
rs	9.4285

"""Integration tests for nested attributes."""
# pylint: disable=missing-docstring,no-self-use,attribute-defined-outside-init,no-member,misplaced-comparison-constant



from unittest.mock import patch
import logging

import yorm

from . import strip


@yorm.attr(status=yorm.types.Boolean)
class StatusDictionary(yorm.types.Dictionary):

    pass


@yorm.attr(all=yorm.types.Float)
class NestedList3(yorm.types.List):

    def __repr__(self):
        return "<nested-list-3 {}>".format((id(self)))


@yorm.attr(nested_list_3=NestedList3)
@yorm.attr(number=yorm.types.Float)
class NestedDictionary3(yorm.types.AttributeDictionary):

    def __init__(self):
        super().__init__()
        self.number = 0
        self.nested_list_3 = []

    def __repr__(self):
        print(self.number)  # trigger a potential recursion issue
        return "<nested-dictionary-3 {}>".format((id(self)))


@yorm.attr(all=yorm.types.Float)
class NestedList2(yorm.types.List):

    def __repr__(self):
        return "<nested-list-2 {}>".format((id(self)))


@yorm.attr(nested_dict_3=NestedDictionary3)
@yorm.attr(number=yorm.types.Float)
class NestedDictionary2(yorm.types.AttributeDictionary):

    def __init__(self):
        super().__init__()
        self.number = 0

    def __repr__(self):
        print(self.number)  # trigger a potential recursion issue
        return "<nested-dictionary-2 {}>".format((id(self)))


@yorm.attr(nested_list_2=NestedList2)
@yorm.attr(number=yorm.types.Float)
class NestedDictionary(yorm.types.AttributeDictionary):

    def __init__(self):
        super().__init__()
        self.number = 0
        self.nested_list_2 = []

    def __repr__(self):
        return "<nested-dictionary {}>".format((id(self)))


@yorm.attr(all=NestedDictionary2)
class NestedList(yorm.types.List):

    def __repr__(self):
        return "<nested-list {}>".format((id(self)))


@yorm.attr(nested_dict=NestedDictionary)
@yorm.attr(nested_list=NestedList)
@yorm.sync("sample.yml")
class Top:

    def __init__(self):
        self.nested_list = []
        self.nested_dict = {}

    def __repr__(self):
        return "<top {}>".format((id(self)))


@patch('yorm.settings.fake', True)
class TestNestedOnce:

    def test_append_triggers_save(self):
        top = Top()
        logging.info("Appending dictionary to list...")
        top.nested_list.append({'number': 1})
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.0
        """) == top.__mapper__.text

    def test_set_by_index_triggers_save(self):
        top = Top()
        top.nested_list = [{'number': 1.5}]
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.5
        """) == top.__mapper__.text
        top.nested_list[0] = {'number': 1.6}
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.6
        """) == top.__mapper__.text

    def test_get_by_index_triggers_load(self):
        top = Top()
        top.__mapper__.text = strip("""
        nested_list:
        - number: 1.7
        """)
        assert 1.7 == top.nested_list[0].number

    def test_delete_index_triggers_save(self):
        top = Top()
        top.nested_list = [{'number': 1.8}, {'number': 1.9}]
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.8
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.9
        """) == top.__mapper__.text
        del top.nested_list[0]
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 1.9
        """) == top.__mapper__.text

    def test_set_dict_as_attribute_triggers_save(self):
        top = Top()
        top.nested_dict.number = 2
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 2.0
        nested_list: []
        """) == top.__mapper__.text


@patch('yorm.settings.fake', True)
class TestNestedTwice:

    def test_nested_list_item_value_change_triggers_save(self):
        top = Top()
        top.nested_list = [{'number': 3}]
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 3.0
        """) == top.__mapper__.text
        top.nested_list[0].number = 4
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 0.0
          number: 4.0
        """) == top.__mapper__.text

    def test_nested_dict_item_value_change_triggers_save(self):
        top = Top()
        top.nested_dict = {'nested_list_2': [5]}
        assert strip("""
        nested_dict:
          nested_list_2:
          - 5.0
          number: 0.0
        nested_list: []
        """) == top.__mapper__.text
        top.nested_dict.nested_list_2.append(6)
        assert strip("""
        nested_dict:
          nested_list_2:
          - 5.0
          - 6.0
          number: 0.0
        nested_list: []
        """) == top.__mapper__.text

    def test_dict_in_list_value_change_triggers_save(self):
        top = Top()
        top.nested_list.append(None)
        top.nested_list[0].nested_dict_3.number = 8
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3: []
            number: 8.0
          number: 0.0
        """) == top.__mapper__.text

    def test_list_in_dict_append_triggers_save(self):
        top = Top()
        top.nested_list.append(None)
        top.nested_list.append(None)
        for nested_dict_2 in top.nested_list:
            nested_dict_2.number = 9
            nested_dict_2.nested_dict_3.nested_list_3.append(10)
        assert strip("""
        nested_dict:
          nested_list_2: []
          number: 0.0
        nested_list:
        - nested_dict_3:
            nested_list_3:
            - 10.0
            number: 0.0
          number: 9.0
        - nested_dict_3:
            nested_list_3:
            - 10.0
            number: 0.0
          number: 9.0
        """) == top.__mapper__.text


@patch('yorm.settings.fake', True)
class TestAliases:

    @yorm.attr(var4=NestedList3)
    @yorm.attr(var5=StatusDictionary)
    @yorm.sync("fake/path")
    class Sample:

        def __repr__(self):
            return "<sample {}>".format(id(self))

    def setup_method(self, _):
        self.sample = self.Sample()

    @staticmethod
    def _log_ref(name, var, ref):
        logging.info("%s: %r", name, var)
        logging.info("%s_ref: %r", name, ref)
        logging.info("%s ID: %s", name, id(var))
        logging.info("%s_ref ID: %s", name, id(ref))
        assert id(ref) == id(var)
        assert ref == var

    def test_alias_list(self):
        var4_ref = self.sample.var4
        self._log_ref('var4', self.sample.var4, var4_ref)
        assert [] == self.sample.var4

        logging.info("Appending 42 to var4_ref...")
        var4_ref.append(42)
        self._log_ref('var4', self.sample.var4, var4_ref)
        assert [42] == self.sample.var4

        logging.info("Appending 2015 to var4_ref...")
        var4_ref.append(2015)
        assert [42, 2015] == self.sample.var4

    def test_alias_dict(self):
        var5_ref = self.sample.var5
        self._log_ref('var5', self.sample.var5, var5_ref)
        assert {'status': False} == self.sample.var5

        logging.info("Setting status=True in var5_ref...")
        var5_ref['status'] = True
        self._log_ref('var5', self.sample.var5, var5_ref)
        assert {'status': True} == self.sample.var5

        logging.info("Setting status=False in var5_ref...")
        var5_ref['status'] = False
        self._log_ref('var5', self.sample.var5, var5_ref)
        assert {'status': False} == self.sample.var5

    def test_alias_dict_in_list(self):
        top = Top()
        top.nested_list.append(None)
        ref1 = top.nested_list[0]
        ref2 = top.nested_list[0].nested_dict_3
        ref3 = top.nested_list[0].nested_dict_3.nested_list_3
        assert id(ref1) == id(top.nested_list[0])
        assert id(ref2) == id(top.nested_list[0].nested_dict_3)
        assert id(ref3) == id(top.nested_list[0].nested_dict_3.nested_list_3)

    def test_alias_list_in_dict(self):
        top = Top()
        logging.info("Updating nested attribute...")
        top.nested_dict.number = 1
        logging.info("Grabbing refs...")
        ref1 = top.nested_dict
        ref2 = top.nested_dict.nested_list_2
        assert id(ref1) == id(top.nested_dict)
        assert id(ref2) == id(top.nested_dict.nested_list_2)


1			"""Integration tests for nested attributes."""
2			# pylint: disable=missing-docstring,no-self-use,attribute-defined-outside-init,no-member,misplaced-comparison-constant
			0 ignored issues – show introduced 2016-02-13 01:53 UTC by Report Bug Copy Issue Report Bad option value 'misplaced-comparison-constant' Loading history...
3
4
5			from unittest.mock import patch
6			import logging
7
8			import yorm
9
10			from . import strip
11
12
13			@yorm.attr(status=yorm.types.Boolean)
14			class StatusDictionary(yorm.types.Dictionary):
15
16			pass
17
18
19			@yorm.attr(all=yorm.types.Float)
20			class NestedList3(yorm.types.List):
21
22			def __repr__(self):
23			return "<nested-list-3 {}>".format((id(self)))
24
25
26			@yorm.attr(nested_list_3=NestedList3)
27			@yorm.attr(number=yorm.types.Float)
28			class NestedDictionary3(yorm.types.AttributeDictionary):
29
30			def __init__(self):
31			super().__init__()
32			self.number = 0
33			self.nested_list_3 = []
34
35			def __repr__(self):
36			print(self.number) # trigger a potential recursion issue
37			return "<nested-dictionary-3 {}>".format((id(self)))
38
39
40			@yorm.attr(all=yorm.types.Float)
41			class NestedList2(yorm.types.List):
42
43			def __repr__(self):
44			return "<nested-list-2 {}>".format((id(self)))
45
46
47			@yorm.attr(nested_dict_3=NestedDictionary3)
48			@yorm.attr(number=yorm.types.Float)
49			class NestedDictionary2(yorm.types.AttributeDictionary):
50
51			def __init__(self):
52			super().__init__()
53			self.number = 0
54
55			def __repr__(self):
56			print(self.number) # trigger a potential recursion issue
57			return "<nested-dictionary-2 {}>".format((id(self)))
58
59
60			@yorm.attr(nested_list_2=NestedList2)
61			@yorm.attr(number=yorm.types.Float)
62			class NestedDictionary(yorm.types.AttributeDictionary):
63
64			def __init__(self):
65			super().__init__()
66			self.number = 0
67			self.nested_list_2 = []
68
69			def __repr__(self):
70			return "<nested-dictionary {}>".format((id(self)))
71
72
73			@yorm.attr(all=NestedDictionary2)
74			class NestedList(yorm.types.List):
75
76			def __repr__(self):
77			return "<nested-list {}>".format((id(self)))
78
79
80			@yorm.attr(nested_dict=NestedDictionary)
81			@yorm.attr(nested_list=NestedList)
82			@yorm.sync("sample.yml")
83			class Top:
84
85			def __init__(self):
86			self.nested_list = []
87			self.nested_dict = {}
88
89			def __repr__(self):
90			return "<top {}>".format((id(self)))
91
92
93			@patch('yorm.settings.fake', True)
94			class TestNestedOnce:
95
96			def test_append_triggers_save(self):
97			top = Top()
98			logging.info("Appending dictionary to list...")
99			top.nested_list.append({'number': 1})
100			assert strip("""
101			nested_dict:
102			nested_list_2: []
103			number: 0.0
104			nested_list:
105			- nested_dict_3:
106			nested_list_3: []
107			number: 0.0
108			number: 1.0
109			""") == top.__mapper__.text
110
111			def test_set_by_index_triggers_save(self):
112			top = Top()
113			top.nested_list = [{'number': 1.5}]
114			assert strip("""
115			nested_dict:
116			nested_list_2: []
117			number: 0.0
118			nested_list:
119			- nested_dict_3:
120			nested_list_3: []
121			number: 0.0
122			number: 1.5
123			""") == top.__mapper__.text
124			top.nested_list[0] = {'number': 1.6}
125			assert strip("""
126			nested_dict:
127			nested_list_2: []
128			number: 0.0
129			nested_list:
130			- nested_dict_3:
131			nested_list_3: []
132			number: 0.0
133			number: 1.6
134			""") == top.__mapper__.text
135
136			def test_get_by_index_triggers_load(self):
137			top = Top()
138			top.__mapper__.text = strip("""
139			nested_list:
140			- number: 1.7
141			""")
142			assert 1.7 == top.nested_list[0].number
143
144			def test_delete_index_triggers_save(self):
145			top = Top()
146			top.nested_list = [{'number': 1.8}, {'number': 1.9}]
147			assert strip("""
148			nested_dict:
149			nested_list_2: []
150			number: 0.0
151			nested_list:
152			- nested_dict_3:
153			nested_list_3: []
154			number: 0.0
155			number: 1.8
156			- nested_dict_3:
157			nested_list_3: []
158			number: 0.0
159			number: 1.9
160			""") == top.__mapper__.text
161			del top.nested_list[0]
162			assert strip("""
163			nested_dict:
164			nested_list_2: []
165			number: 0.0
166			nested_list:
167			- nested_dict_3:
168			nested_list_3: []
169			number: 0.0
170			number: 1.9
171			""") == top.__mapper__.text
172
173			def test_set_dict_as_attribute_triggers_save(self):
174			top = Top()
175			top.nested_dict.number = 2
176			assert strip("""
177			nested_dict:
178			nested_list_2: []
179			number: 2.0
180			nested_list: []
181			""") == top.__mapper__.text
182
183
184			@patch('yorm.settings.fake', True)
185			class TestNestedTwice:
186
187			def test_nested_list_item_value_change_triggers_save(self):
188			top = Top()
189			top.nested_list = [{'number': 3}]
190			assert strip("""
191			nested_dict:
192			nested_list_2: []
193			number: 0.0
194			nested_list:
195			- nested_dict_3:
196			nested_list_3: []
197			number: 0.0
198			number: 3.0
199			""") == top.__mapper__.text
200			top.nested_list[0].number = 4
201			assert strip("""
202			nested_dict:
203			nested_list_2: []
204			number: 0.0
205			nested_list:
206			- nested_dict_3:
207			nested_list_3: []
208			number: 0.0
209			number: 4.0
210			""") == top.__mapper__.text
211
212			def test_nested_dict_item_value_change_triggers_save(self):
213			top = Top()
214			top.nested_dict = {'nested_list_2': [5]}
215			assert strip("""
216			nested_dict:
217			nested_list_2:
218			- 5.0
219			number: 0.0
220			nested_list: []
221			""") == top.__mapper__.text
222			top.nested_dict.nested_list_2.append(6)
223			assert strip("""
224			nested_dict:
225			nested_list_2:
226			- 5.0
227			- 6.0
228			number: 0.0
229			nested_list: []
230			""") == top.__mapper__.text
231
232			def test_dict_in_list_value_change_triggers_save(self):
233			top = Top()
234			top.nested_list.append(None)
235			top.nested_list[0].nested_dict_3.number = 8
236			assert strip("""
237			nested_dict:
238			nested_list_2: []
239			number: 0.0
240			nested_list:
241			- nested_dict_3:
242			nested_list_3: []
243			number: 8.0
244			number: 0.0
245			""") == top.__mapper__.text
246
247			def test_list_in_dict_append_triggers_save(self):
248			top = Top()
249			top.nested_list.append(None)
250			top.nested_list.append(None)
251			for nested_dict_2 in top.nested_list:
252			nested_dict_2.number = 9
253			nested_dict_2.nested_dict_3.nested_list_3.append(10)
254			assert strip("""
255			nested_dict:
256			nested_list_2: []
257			number: 0.0
258			nested_list:
259			- nested_dict_3:
260			nested_list_3:
261			- 10.0
262			number: 0.0
263			number: 9.0
264			- nested_dict_3:
265			nested_list_3:
266			- 10.0
267			number: 0.0
268			number: 9.0
269			""") == top.__mapper__.text
270
271
272			@patch('yorm.settings.fake', True)
273			class TestAliases:
274
275			@yorm.attr(var4=NestedList3)
276			@yorm.attr(var5=StatusDictionary)
277			@yorm.sync("fake/path")
278			class Sample:
279
280			def __repr__(self):
281			return "<sample {}>".format(id(self))
282
283			def setup_method(self, _):
284			self.sample = self.Sample()
285
286			@staticmethod
287			def _log_ref(name, var, ref):
288			logging.info("%s: %r", name, var)
289			logging.info("%s_ref: %r", name, ref)
290			logging.info("%s ID: %s", name, id(var))
291			logging.info("%s_ref ID: %s", name, id(ref))
292			assert id(ref) == id(var)
293			assert ref == var
294
295			def test_alias_list(self):
296			var4_ref = self.sample.var4
297			self._log_ref('var4', self.sample.var4, var4_ref)
298			assert [] == self.sample.var4
299
300			logging.info("Appending 42 to var4_ref...")
301			var4_ref.append(42)
302			self._log_ref('var4', self.sample.var4, var4_ref)
303			assert [42] == self.sample.var4
304
305			logging.info("Appending 2015 to var4_ref...")
306			var4_ref.append(2015)
307			assert [42, 2015] == self.sample.var4
308
309			def test_alias_dict(self):
310			var5_ref = self.sample.var5
311			self._log_ref('var5', self.sample.var5, var5_ref)
312			assert {'status': False} == self.sample.var5
313
314			logging.info("Setting status=True in var5_ref...")
315			var5_ref['status'] = True
316			self._log_ref('var5', self.sample.var5, var5_ref)
317			assert {'status': True} == self.sample.var5
318
319			logging.info("Setting status=False in var5_ref...")
320			var5_ref['status'] = False
321			self._log_ref('var5', self.sample.var5, var5_ref)
322			assert {'status': False} == self.sample.var5
323
324			def test_alias_dict_in_list(self):
325			top = Top()
326			top.nested_list.append(None)
327			ref1 = top.nested_list[0]
328			ref2 = top.nested_list[0].nested_dict_3
329			ref3 = top.nested_list[0].nested_dict_3.nested_list_3
330			assert id(ref1) == id(top.nested_list[0])
331			assert id(ref2) == id(top.nested_list[0].nested_dict_3)
332			assert id(ref3) == id(top.nested_list[0].nested_dict_3.nested_list_3)
333
334			def test_alias_list_in_dict(self):
335			top = Top()
336			logging.info("Updating nested attribute...")
337			top.nested_dict.number = 1
338			logging.info("Grabbing refs...")
339			ref1 = top.nested_dict
340			ref2 = top.nested_dict.nested_list_2
341			assert id(ref1) == id(top.nested_dict)
342			assert id(ref2) == id(top.nested_dict.nested_list_2)
343

jacebrowning / yorm

Pull Request — develop (#117)

TestNestedOnce.test_append_triggers_save() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like