TestStarStruct.test_verifying_unpack() - Code Metrics - Inspection of "Add callable function item" - sprout42/StarStruct - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#35)

unknown

created 2016-11-30 21:56 UTC

TestStarStruct.test_verifying_unpack() F

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	16
c	1
b	0
f	0
dl	0
loc	82
rs	2.0442

How to fix Long Method Complexity

#!/usr/bin/env python3

"""Tests for the starstruct class"""

# import struct
import unittest
from binascii import crc32

import pytest

from starstruct.message import Message
# from starstruct.modes import Mode


# pylint: disable=line-too-long,invalid-name
class TestStarStruct(unittest.TestCase):
    """StarStruct module tests"""

    VarTest = Message('VarTest', [
        ('x', 'B'),
        ('y', 'B'),
    ])

    Repeated = Message('Repeated', [
        ('x', 'B'),
        ('z', 'H'),
    ])

    def test_single_element_2(self):
        TestStruct = Message('TestStruct', [
            ('length_in_objects', 'H', 'vardata'),
            ('vardata', self.VarTest, 'length_in_objects'),
        ])

        CRCedMessage = Message('CRCedMessage', [
            ('data', TestStruct),
            ('function_data', 'I', crc32, [b'data']),
        ])

        test_data = {
            'data': {
                'length_in_objects': 2,
                'vardata': [
                    {'x': 1, 'y': 2},
                    {'x': 3, 'y': 4},
                ],
            },
        }

        made = CRCedMessage.make(test_data)
        # assert len(made) == 5
        assert len(made.data.vardata) == 2
        assert made.data.vardata[0].x == 1
        assert made.data.vardata[0].y == 2
        assert made.function_data == crc32(TestStruct.pack(test_data['data']))

    def test_one_element(self):
        def crc32_wrapper(*args):
            return crc32(b''.join(args))

        CompareMessage = Message('CompareMessage', [
            ('length_in_objects', 'H', 'vardata'),
            ('vardata', self.VarTest, 'length_in_objects'),
        ])

        CRCedMessage = Message('TestStruct', [
            ('length_in_objects', 'H', 'vardata'),
            ('vardata', self.VarTest, 'length_in_objects'),
            ('function_data', 'I', crc32_wrapper, [b'length_in_objects', b'vardata']),
        ])

        test_data = {
            'length_in_objects': 2,
            'vardata': [
                {'x': 1, 'y': 2},
                {'x': 3, 'y': 4},
            ],
        }

        made = CRCedMessage.make(test_data)
        # assert len(made) == 5
        assert len(made.vardata) == 2
        assert made.vardata[0].x == 1
        assert made.vardata[0].y == 2

        assert made.function_data == crc32(CompareMessage.pack(test_data))

    def test_adding_element(self):
class Foo:
    def some_method(self, x, y):
        return x + y;
        def adder(x, y):
            return x + y

        AdderMessage = Message('AdderMessage', [
            ('item_a', 'H'),
            ('item_b', 'B'),
            ('function_data', 'I', adder, ['item_a', 'item_b']),
        ])

        test_data = {
            'item_a': 2,
            'item_b': 5,
        }

        made = AdderMessage.make(test_data)
        assert made.item_a == 2
        assert made.item_b == 5

        assert made.function_data == 7

    def test_adding_element_list(self):
class Foo:
    def some_method(self, x, y):
        return x + y;
        def adder(*args):
            return sum(args)

        AdderMessage = Message('AdderMessage', [
            ('item_a', 'H'),
            ('item_b', 'B'),
            ('item_c', 'B'),
            ('item_d', 'B'),
            ('item_e', 'B'),
            # Note, there is no item 'e' in the list of arguments
            ('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d']),
        ])

        # Test getting the correct result
        test_data = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
        }

        made = AdderMessage.make(test_data)
        assert made.item_a == 2
        assert made.item_b == 5

        assert made.function_data == 2 + 5 + 7 + 4

        # Check packing and unpacking
        packed = AdderMessage.pack(test_data)
        assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
        assert packed == made.pack()

        unpacked = AdderMessage.unpack(packed)
        assert made == unpacked

        # Test with correct result
        test_data_2 = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
            'function_data': 2 + 5 + 7 + 4,
        }
        made = AdderMessage.make(test_data_2)
        assert made.item_a == 2
        assert made.item_b == 5

        assert made.function_data == 2 + 5 + 7 + 4

        # Test with incorrect result
        test_data_2 = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
            'function_data': -1,
        }

        with pytest.raises(ValueError):
            made = AdderMessage.make(test_data_2)

    def test_no_error_message(self):
class Foo:
    def some_method(self, x, y):
        return x + y;
        def adder(*args):
            return sum(args)

        AdderMessage = Message('AdderMessage', [
            ('item_a', 'H'),
            ('item_b', 'B'),
            ('item_c', 'B'),
            ('item_d', 'B'),
            ('item_e', 'B'),
            # Note, there is no item 'e' in the list of arguments
            ('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d'], False),
        ])

        # Test with incorrect result
        test_data_2 = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
            'function_data': -1,
        }

        made = AdderMessage.make(test_data_2)
        assert made.function_data == -1

    def test_verifying_unpack(self):
class Foo:
    def some_method(self, x, y):
        return x + y;
        def adder(*args):
            return sum(args)

        AdderMessage = Message('AdderMessage', [
            ('item_a', 'H'),
            ('item_b', 'B'),
            ('item_c', 'B'),
            ('item_d', 'B'),
            ('item_e', 'B'),
            # Note, there is no item 'e' in the list of arguments
            ('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d']),
        ])

        # Test getting the correct result
        test_data = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
        }

        made = AdderMessage.make(test_data)
        assert made.item_a == 2
        assert made.item_b == 5

        assert made.function_data == 2 + 5 + 7 + 4

        # Check packing and unpacking
        packed = AdderMessage.pack(test_data)
        assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
        assert packed == made.pack()

        unpacked = AdderMessage.unpack(packed)
        assert made == unpacked

        # Now we modify the data we are going to unpack, and we should get an error
        modified_packed = b'\x02\x00\x05\x07\x04\x06\x11\x11\x11\x11'

        with pytest.raises(ValueError):
            unpacked = AdderMessage.unpack(modified_packed)

        AdderMessageFalse = Message('AdderMessageFalse', [
            ('item_a', 'H'),
            ('item_b', 'B'),
            ('item_c', 'B'),
            ('item_d', 'B'),
            ('item_e', 'B'),
            # Note, there is no item 'e' in the list of arguments
            ('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d'], False),
        ])

        # Test getting the correct result
        test_data = {
            'item_a': 2,
            'item_b': 5,
            'item_c': 7,
            'item_d': 4,
            'item_e': 6,
        }

        made = AdderMessageFalse.make(test_data)
        assert made.item_a == 2
        assert made.item_b == 5

        assert made.function_data == 2 + 5 + 7 + 4

        # Check packing and unpacking
        packed = AdderMessageFalse.pack(test_data)
        assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
        assert packed == made.pack()

        unpacked = AdderMessageFalse.unpack(packed)
        assert made == unpacked

        # Now we modify the data we are going to unpack, and we should get an error
        modified_packed = b'\x02\x00\x05\x07\x04\x06\x11\x11\x11\x11'

        # This time it won't fail because we set False for this message
        unpacked = AdderMessageFalse.unpack(modified_packed)
        assert unpacked.item_a == 2


1			#!/usr/bin/env python3
2
3			"""Tests for the starstruct class"""
4
5			# import struct
6			import unittest
7			from binascii import crc32
8
9			import pytest
10
11			from starstruct.message import Message
12			# from starstruct.modes import Mode
13
14
15			# pylint: disable=line-too-long,invalid-name
16			class TestStarStruct(unittest.TestCase):
17			"""StarStruct module tests"""
18
19			VarTest = Message('VarTest', [
20			('x', 'B'),
21			('y', 'B'),
22			])
23
24			Repeated = Message('Repeated', [
25			('x', 'B'),
26			('z', 'H'),
27			])
28
29			def test_single_element_2(self):
30			TestStruct = Message('TestStruct', [
31			('length_in_objects', 'H', 'vardata'),
32			('vardata', self.VarTest, 'length_in_objects'),
33			])
34
35			CRCedMessage = Message('CRCedMessage', [
36			('data', TestStruct),
37			('function_data', 'I', crc32, [b'data']),
38			])
39
40			test_data = {
41			'data': {
42			'length_in_objects': 2,
43			'vardata': [
44			{'x': 1, 'y': 2},
45			{'x': 3, 'y': 4},
46			],
47			},
48			}
49
50			made = CRCedMessage.make(test_data)
51			# assert len(made) == 5
52			assert len(made.data.vardata) == 2
53			assert made.data.vardata[0].x == 1
54			assert made.data.vardata[0].y == 2
55			assert made.function_data == crc32(TestStruct.pack(test_data['data']))
56
57			def test_one_element(self):
58			def crc32_wrapper(*args):
59			return crc32(b''.join(args))
60
61			CompareMessage = Message('CompareMessage', [
62			('length_in_objects', 'H', 'vardata'),
63			('vardata', self.VarTest, 'length_in_objects'),
64			])
65
66			CRCedMessage = Message('TestStruct', [
67			('length_in_objects', 'H', 'vardata'),
68			('vardata', self.VarTest, 'length_in_objects'),
69			('function_data', 'I', crc32_wrapper, [b'length_in_objects', b'vardata']),
70			])
71
72			test_data = {
73			'length_in_objects': 2,
74			'vardata': [
75			{'x': 1, 'y': 2},
76			{'x': 3, 'y': 4},
77			],
78			}
79
80			made = CRCedMessage.make(test_data)
81			# assert len(made) == 5
82			assert len(made.vardata) == 2
83			assert made.vardata[0].x == 1
84			assert made.vardata[0].y == 2
85
86			assert made.function_data == crc32(CompareMessage.pack(test_data))
87
88			def test_adding_element(self):
			0 ignored issues – show Coding Style introduced 2016-11-30 19:25 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
89			def adder(x, y):
90			return x + y
91
92			AdderMessage = Message('AdderMessage', [
93			('item_a', 'H'),
94			('item_b', 'B'),
95			('function_data', 'I', adder, ['item_a', 'item_b']),
96			])
97
98			test_data = {
99			'item_a': 2,
100			'item_b': 5,
101			}
102
103			made = AdderMessage.make(test_data)
104			assert made.item_a == 2
105			assert made.item_b == 5
106
107			assert made.function_data == 7
108
109			def test_adding_element_list(self):
			0 ignored issues – show Coding Style introduced 2016-11-30 19:25 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
110			def adder(*args):
111			return sum(args)
112
113			AdderMessage = Message('AdderMessage', [
114			('item_a', 'H'),
115			('item_b', 'B'),
116			('item_c', 'B'),
117			('item_d', 'B'),
118			('item_e', 'B'),
119			# Note, there is no item 'e' in the list of arguments
120			('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d']),
121			])
122
123			# Test getting the correct result
124			test_data = {
125			'item_a': 2,
126			'item_b': 5,
127			'item_c': 7,
128			'item_d': 4,
129			'item_e': 6,
130			}
131
132			made = AdderMessage.make(test_data)
133			assert made.item_a == 2
134			assert made.item_b == 5
135
136			assert made.function_data == 2 + 5 + 7 + 4
137
138			# Check packing and unpacking
139			packed = AdderMessage.pack(test_data)
140			assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
141			assert packed == made.pack()
142
143			unpacked = AdderMessage.unpack(packed)
144			assert made == unpacked
145
146			# Test with correct result
147			test_data_2 = {
148			'item_a': 2,
149			'item_b': 5,
150			'item_c': 7,
151			'item_d': 4,
152			'item_e': 6,
153			'function_data': 2 + 5 + 7 + 4,
154			}
155			made = AdderMessage.make(test_data_2)
156			assert made.item_a == 2
157			assert made.item_b == 5
158
159			assert made.function_data == 2 + 5 + 7 + 4
160
161			# Test with incorrect result
162			test_data_2 = {
163			'item_a': 2,
164			'item_b': 5,
165			'item_c': 7,
166			'item_d': 4,
167			'item_e': 6,
168			'function_data': -1,
169			}
170
171			with pytest.raises(ValueError):
172			made = AdderMessage.make(test_data_2)
173
174			def test_no_error_message(self):
			0 ignored issues – show Coding Style introduced 2016-11-30 19:25 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
175			def adder(*args):
176			return sum(args)
177
178			AdderMessage = Message('AdderMessage', [
179			('item_a', 'H'),
180			('item_b', 'B'),
181			('item_c', 'B'),
182			('item_d', 'B'),
183			('item_e', 'B'),
184			# Note, there is no item 'e' in the list of arguments
185			('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d'], False),
186			])
187
188			# Test with incorrect result
189			test_data_2 = {
190			'item_a': 2,
191			'item_b': 5,
192			'item_c': 7,
193			'item_d': 4,
194			'item_e': 6,
195			'function_data': -1,
196			}
197
198			made = AdderMessage.make(test_data_2)
199			assert made.function_data == -1
200
201			def test_verifying_unpack(self):
			0 ignored issues – show Coding Style introduced 2016-11-30 22:00 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
202			def adder(*args):
203			return sum(args)
204
205			AdderMessage = Message('AdderMessage', [
206			('item_a', 'H'),
207			('item_b', 'B'),
208			('item_c', 'B'),
209			('item_d', 'B'),
210			('item_e', 'B'),
211			# Note, there is no item 'e' in the list of arguments
212			('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d']),
213			])
214
215			# Test getting the correct result
216			test_data = {
217			'item_a': 2,
218			'item_b': 5,
219			'item_c': 7,
220			'item_d': 4,
221			'item_e': 6,
222			}
223
224			made = AdderMessage.make(test_data)
225			assert made.item_a == 2
226			assert made.item_b == 5
227
228			assert made.function_data == 2 + 5 + 7 + 4
229
230			# Check packing and unpacking
231			packed = AdderMessage.pack(test_data)
232			assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
233			assert packed == made.pack()
234
235			unpacked = AdderMessage.unpack(packed)
236			assert made == unpacked
237
238			# Now we modify the data we are going to unpack, and we should get an error
239			modified_packed = b'\x02\x00\x05\x07\x04\x06\x11\x11\x11\x11'
240
241			with pytest.raises(ValueError):
242			unpacked = AdderMessage.unpack(modified_packed)
243
244			AdderMessageFalse = Message('AdderMessageFalse', [
245			('item_a', 'H'),
246			('item_b', 'B'),
247			('item_c', 'B'),
248			('item_d', 'B'),
249			('item_e', 'B'),
250			# Note, there is no item 'e' in the list of arguments
251			('function_data', 'I', adder, ['item_a', 'item_b', 'item_c', 'item_d'], False),
252			])
253
254			# Test getting the correct result
255			test_data = {
256			'item_a': 2,
257			'item_b': 5,
258			'item_c': 7,
259			'item_d': 4,
260			'item_e': 6,
261			}
262
263			made = AdderMessageFalse.make(test_data)
264			assert made.item_a == 2
265			assert made.item_b == 5
266
267			assert made.function_data == 2 + 5 + 7 + 4
268
269			# Check packing and unpacking
270			packed = AdderMessageFalse.pack(test_data)
271			assert packed == b'\x02\x00\x05\x07\x04\x06\x12\x00\x00\x00'
272			assert packed == made.pack()
273
274			unpacked = AdderMessageFalse.unpack(packed)
275			assert made == unpacked
276
277			# Now we modify the data we are going to unpack, and we should get an error
278			modified_packed = b'\x02\x00\x05\x07\x04\x06\x11\x11\x11\x11'
279
280			# This time it won't fail because we set False for this message
281			unpacked = AdderMessageFalse.unpack(modified_packed)
282			assert unpacked.item_a == 2
283

sprout42 / StarStruct

Pull Request — master (#35)

TestStarStruct.test_verifying_unpack() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like