TestPortRange - Code Metrics - Inspection of "Refactor parsing." - scaleway/port-range - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( b7d53e...9f91db )

by A

created 2016-12-16 15:03 UTC

TestPortRange A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	166
Duplicated Lines	14.46 %

Importance

Changes	9
Bugs	0	Features	0

Metric	Value
c	9
b	0
f	0
dl	24
loc	166
rs	10
wmc	12

11 Methods

Rating	Name	Duplication	Size	Complexity
A	test_cidr_parsing()	0	3	1
A	test_cidr_string_rendering()	0	5	2
A	test_output_string()	0	9	1
A	test_strict_mode()	0	8	1
A	test_computation()	0	3	1
A	test_range_properties()	0	11	1
A	test_cidr_properties()	0	10	1
B	test_strict_range_parsing()	24	25	1
B	test_range_parsing()	0	24	1
B	test_validation()	0	41	1
A	test_normalization()	0	14	1

How to fix Duplicated Code

# -*- coding: utf-8 -*-
#
# Copyright (c) 2014-2016 Scaleway and Contributors. All Rights Reserved.
#                         Kevin Deldycke <[email protected]>
#
# Licensed under the BSD 2-Clause License (the "License"); you may not use this
# file except in compliance with the License. You may obtain a copy of the
# License at https://opensource.org/licenses/BSD-2-Clause

from __future__ import (
    absolute_import,
    division,
    print_function,
    unicode_literals
)

import unittest

from port_range import PortRange


class TestPortRange(unittest.TestCase):

    def test_cidr_parsing(self):
        self.assertEqual(PortRange('1027/15').bounds, (1027, 1028))
        self.assertEqual(PortRange(' 1027 / 15 ').bounds, (1027, 1028))

    def test_range_parsing(self):
        # Normal range.
        self.assertEqual(PortRange('42-4242').bounds, (42, 4242))
        self.assertEqual(PortRange([42, 4242]).bounds, (42, 4242))
        self.assertEqual(PortRange(['42', '4242']).bounds, (42, 4242))

        # Single port.
        self.assertEqual(PortRange('42').bounds, (42, 42))
        self.assertEqual(PortRange(42).bounds, (42, 42))
        self.assertEqual(PortRange([42]).bounds, (42, 42))
        self.assertEqual(PortRange(['42']).bounds, (42, 42))

        # Reversed order.
        self.assertEqual(PortRange('4242-42').bounds, (42, 4242))
        self.assertEqual(PortRange([4242, 42]).bounds, (42, 4242))
        self.assertEqual(PortRange((4242, 42)).bounds, (42, 4242))
        self.assertEqual(PortRange(('4242', '42')).bounds, (42, 4242))
        self.assertEqual(PortRange(set([4242, 42])).bounds, (42, 4242))
        self.assertEqual(PortRange(set(['4242', '42'])).bounds, (42, 4242))

        # Invalid types and lenght.
        self.assertRaises(ValueError, PortRange, [None, 42])
        self.assertRaises(ValueError, PortRange, [42, None])
        self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4])

    def test_strict_range_parsing(self):

        # Normal range.
        self.assertEqual(PortRange('42-4242', strict=True).bounds, (42, 4242))
        self.assertEqual(PortRange([42, 4242], strict=True).bounds, (42, 4242))
        self.assertEqual(PortRange(['42', '4242'], strict=True).bounds, (42, 4242))

        # Single port.
        self.assertEqual(PortRange('42', strict=True).bounds, (42, 42))
        self.assertEqual(PortRange(42, strict=True).bounds, (42, 42))
        self.assertEqual(PortRange([42], strict=True).bounds, (42, 42))
        self.assertEqual(PortRange(['42'], strict=True).bounds, (42, 42))

        # Reversed order.

        self.assertRaises(ValueError, PortRange, [4242, 42], True)
        self.assertRaises(ValueError, PortRange, '4242-42', True)
        self.assertRaises(ValueError, PortRange, (4242, 42), True)
        self.assertRaises(ValueError, PortRange, ('4242', '42'), True)
        # Casting a set to a list might ends up with a naturally sorted list.
        # self.assertRaises(ValueError, PortRange, set([4242, 42]), True)
        # self.assertRaises(ValueError, PortRange, set(['4242', '42']), True)

        # Invalid types and lenght.
        self.assertRaises(ValueError, PortRange, [None, 42], True)
        self.assertRaises(ValueError, PortRange, [42, None], True)
        self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4], True)

    def test_cidr_properties(self):
        port = PortRange('1027/15')
        self.assertEqual(port.base, 1027)
        self.assertEqual(port.prefix, 15)
        self.assertEqual(port.cidr, (1027, 15))
        self.assertEqual(port.mask, 1)
        self.assertEqual(port.offset, 3)
        self.assertEqual(port.port_from, 1027)
        self.assertEqual(port.port_to, 1028)
        self.assertEqual(port.bounds, (1027, 1028))

    def test_range_properties(self):
        port = PortRange([4242, 42])
        self.assertEqual(str(port), '42-4242')
        self.assertEqual(port.base, 42)
        self.assertEqual(port.prefix, None)
        self.assertEqual(port.cidr, (42, None))
        self.assertEqual(port.mask, None)
        self.assertEqual(port.offset, 10)
        self.assertEqual(port.port_from, 42)
        self.assertEqual(port.port_to, 4242)
        self.assertEqual(port.bounds, (42, 4242))

    def test_normalization(self):
        port = PortRange(' 0001234 ')
        self.assertEqual(str(port), '1234')
        self.assertEqual(port.base, 1234)
        self.assertEqual(port.prefix, 16)
        self.assertEqual(port.cidr, (1234, 16))
        self.assertEqual(port.mask, 0)
        self.assertEqual(port.offset, 210)
        self.assertEqual(port.port_from, 1234)
        self.assertEqual(port.port_to, 1234)
        self.assertEqual(port.bounds, (1234, 1234))

        # Upper-bound cap.
        self.assertEqual(PortRange('64666/3').bounds, (64666, 65535))

    def test_output_string(self):
        self.assertEqual(str(PortRange('1027/15')), '1027/15')
        self.assertEqual(str(PortRange([42, 4242])), '42-4242')
        self.assertEqual(str(PortRange(42)), '42')
        self.assertEqual(str(PortRange([1027, 1028])), '1027/15')

        self.assertEqual(
            repr(PortRange([1027, 1028])),
            "PortRange(port_from=1027, port_to=1028, base=1027, offset=3, "
            "prefix=15, mask=1, is_single_port=False, is_cidr=True)")

    def test_cidr_string_rendering(self):
        self.assertEqual(PortRange([32768, 65535]).cidr_string, '32768/1')
        self.assertEqual(PortRange([32767, 65534]).cidr_string, '32767/1')
        with self.assertRaises(ValueError):
            PortRange([32767, 65535]).cidr_string

    def test_validation(self):
        # Test empty params
        self.assertRaises(ValueError, PortRange, None)
        self.assertRaises(ValueError, PortRange, [None])
        self.assertRaises(ValueError, PortRange, [None, None])

        # Invalid int
        self.assertRaises(ValueError, PortRange, ' A233 ')
        self.assertRaises(ValueError, PortRange, '1 2 3 4')
        self.assertRaises(ValueError, PortRange, 'abcd')

        # Test negative values
        self.assertRaises(ValueError, PortRange, '-24')
        self.assertRaises(ValueError, PortRange, '-24/3')
        self.assertRaises(ValueError, PortRange, '1024/-3')
        self.assertRaises(ValueError, PortRange, '-1000/-3')
        self.assertRaises(ValueError, PortRange, '-3/-1000')
        self.assertRaises(ValueError, PortRange, ' - 24')
        self.assertRaises(ValueError, PortRange, ' - 24 / 3')
        self.assertRaises(ValueError, PortRange, ' 1024 / - 3')
        self.assertRaises(ValueError, PortRange, ' - 1000 / -  3')
        self.assertRaises(ValueError, PortRange, ' -  3/  - 1000 ')

        # Test maximums and minimums
        self.assertRaises(ValueError, PortRange, '1024/0')
        self.assertRaises(ValueError, PortRange, '1024/17')
        self.assertRaises(ValueError, PortRange, '10-66666', strict=True)

        # Test capping.
        self.assertEqual(PortRange('0').bounds, (1, 1))
        self.assertRaises(ValueError, PortRange, '0', True)
        self.assertEqual(PortRange('66666').bounds, (65535, 65535))
        self.assertRaises(ValueError, PortRange, '66666', True)

        # Test notation
        self.assertRaises(ValueError, PortRange, '23/')
        self.assertRaises(ValueError, PortRange, '/4')
        self.assertRaises(ValueError, PortRange, '/4')
        self.assertRaises(ValueError, PortRange, '400-')
        self.assertRaises(ValueError, PortRange, '123 /  123/ 123')
        self.assertRaises(ValueError, PortRange, ' 123 - 31123- 1323')

    def test_strict_mode(self):
        # Test power of two port base
        PortRange('257', strict=True)
        PortRange('257/16', strict=True)
        self.assertRaises(ValueError, PortRange, '257/4', strict=True)

        # Test overflowing upper bound
        self.assertRaises(ValueError, PortRange, '65535/8', strict=True)

    def test_computation(self):
        self.assertEqual(PortRange('2/3').bounds, (2, 8193))
        self.assertEqual(PortRange('7/3').bounds, (7, 8198))


1		# -- coding: utf-8 --
2		#
3		# Copyright (c) 2014-2016 Scaleway and Contributors. All Rights Reserved.
4		# Kevin Deldycke <[email protected]>
5		#
6		# Licensed under the BSD 2-Clause License (the "License"); you may not use this
7		# file except in compliance with the License. You may obtain a copy of the
8		# License at https://opensource.org/licenses/BSD-2-Clause
9
10		from __future__ import (
11		absolute_import,
12		division,
13		print_function,
14		unicode_literals
15		)
16
17		import unittest
18
19		from port_range import PortRange
20
21
22		class TestPortRange(unittest.TestCase):
23
24		def test_cidr_parsing(self):
25		self.assertEqual(PortRange('1027/15').bounds, (1027, 1028))
26		self.assertEqual(PortRange(' 1027 / 15 ').bounds, (1027, 1028))
27
28		def test_range_parsing(self):
29		# Normal range.
30		self.assertEqual(PortRange('42-4242').bounds, (42, 4242))
31		self.assertEqual(PortRange([42, 4242]).bounds, (42, 4242))
32		self.assertEqual(PortRange(['42', '4242']).bounds, (42, 4242))
33
34		# Single port.
35		self.assertEqual(PortRange('42').bounds, (42, 42))
36		self.assertEqual(PortRange(42).bounds, (42, 42))
37		self.assertEqual(PortRange([42]).bounds, (42, 42))
38		self.assertEqual(PortRange(['42']).bounds, (42, 42))
39
40		# Reversed order.
41		self.assertEqual(PortRange('4242-42').bounds, (42, 4242))
42		self.assertEqual(PortRange([4242, 42]).bounds, (42, 4242))
43		self.assertEqual(PortRange((4242, 42)).bounds, (42, 4242))
44		self.assertEqual(PortRange(('4242', '42')).bounds, (42, 4242))
45		self.assertEqual(PortRange(set([4242, 42])).bounds, (42, 4242))
46		self.assertEqual(PortRange(set(['4242', '42'])).bounds, (42, 4242))
47
48		# Invalid types and lenght.
49		self.assertRaises(ValueError, PortRange, [None, 42])
50		self.assertRaises(ValueError, PortRange, [42, None])
51		self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4])
52
53	View Code Duplication	def test_strict_range_parsing(self):
		0 ignored issues – show Duplication introduced 2016-12-15 12:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
54		# Normal range.
55		self.assertEqual(PortRange('42-4242', strict=True).bounds, (42, 4242))
56		self.assertEqual(PortRange([42, 4242], strict=True).bounds, (42, 4242))
57		self.assertEqual(PortRange(['42', '4242'], strict=True).bounds, (42, 4242))
58
59		# Single port.
60		self.assertEqual(PortRange('42', strict=True).bounds, (42, 42))
61		self.assertEqual(PortRange(42, strict=True).bounds, (42, 42))
62		self.assertEqual(PortRange([42], strict=True).bounds, (42, 42))
63		self.assertEqual(PortRange(['42'], strict=True).bounds, (42, 42))
64
65	View Code Duplication	# Reversed order.
		0 ignored issues – show Duplication introduced 2016-12-15 12:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
66		self.assertRaises(ValueError, PortRange, [4242, 42], True)
67		self.assertRaises(ValueError, PortRange, '4242-42', True)
68		self.assertRaises(ValueError, PortRange, (4242, 42), True)
69		self.assertRaises(ValueError, PortRange, ('4242', '42'), True)
70		# Casting a set to a list might ends up with a naturally sorted list.
71		# self.assertRaises(ValueError, PortRange, set([4242, 42]), True)
72		# self.assertRaises(ValueError, PortRange, set(['4242', '42']), True)
73
74		# Invalid types and lenght.
75		self.assertRaises(ValueError, PortRange, [None, 42], True)
76		self.assertRaises(ValueError, PortRange, [42, None], True)
77		self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4], True)
78
79		def test_cidr_properties(self):
80		port = PortRange('1027/15')
81		self.assertEqual(port.base, 1027)
82		self.assertEqual(port.prefix, 15)
83		self.assertEqual(port.cidr, (1027, 15))
84		self.assertEqual(port.mask, 1)
85		self.assertEqual(port.offset, 3)
86		self.assertEqual(port.port_from, 1027)
87		self.assertEqual(port.port_to, 1028)
88		self.assertEqual(port.bounds, (1027, 1028))
89
90		def test_range_properties(self):
91		port = PortRange([4242, 42])
92		self.assertEqual(str(port), '42-4242')
93		self.assertEqual(port.base, 42)
94		self.assertEqual(port.prefix, None)
95		self.assertEqual(port.cidr, (42, None))
96		self.assertEqual(port.mask, None)
97		self.assertEqual(port.offset, 10)
98		self.assertEqual(port.port_from, 42)
99		self.assertEqual(port.port_to, 4242)
100		self.assertEqual(port.bounds, (42, 4242))
101
102		def test_normalization(self):
103		port = PortRange(' 0001234 ')
104		self.assertEqual(str(port), '1234')
105		self.assertEqual(port.base, 1234)
106		self.assertEqual(port.prefix, 16)
107		self.assertEqual(port.cidr, (1234, 16))
108		self.assertEqual(port.mask, 0)
109		self.assertEqual(port.offset, 210)
110		self.assertEqual(port.port_from, 1234)
111		self.assertEqual(port.port_to, 1234)
112		self.assertEqual(port.bounds, (1234, 1234))
113
114		# Upper-bound cap.
115		self.assertEqual(PortRange('64666/3').bounds, (64666, 65535))
116
117		def test_output_string(self):
118		self.assertEqual(str(PortRange('1027/15')), '1027/15')
119		self.assertEqual(str(PortRange([42, 4242])), '42-4242')
120		self.assertEqual(str(PortRange(42)), '42')
121		self.assertEqual(str(PortRange([1027, 1028])), '1027/15')
122
123		self.assertEqual(
124		repr(PortRange([1027, 1028])),
125		"PortRange(port_from=1027, port_to=1028, base=1027, offset=3, "
126		"prefix=15, mask=1, is_single_port=False, is_cidr=True)")
127
128		def test_cidr_string_rendering(self):
129		self.assertEqual(PortRange([32768, 65535]).cidr_string, '32768/1')
130		self.assertEqual(PortRange([32767, 65534]).cidr_string, '32767/1')
131		with self.assertRaises(ValueError):
132		PortRange([32767, 65535]).cidr_string
133
134		def test_validation(self):
135		# Test empty params
136		self.assertRaises(ValueError, PortRange, None)
137		self.assertRaises(ValueError, PortRange, [None])
138		self.assertRaises(ValueError, PortRange, [None, None])
139
140		# Invalid int
141		self.assertRaises(ValueError, PortRange, ' A233 ')
142		self.assertRaises(ValueError, PortRange, '1 2 3 4')
143		self.assertRaises(ValueError, PortRange, 'abcd')
144
145		# Test negative values
146		self.assertRaises(ValueError, PortRange, '-24')
147		self.assertRaises(ValueError, PortRange, '-24/3')
148		self.assertRaises(ValueError, PortRange, '1024/-3')
149		self.assertRaises(ValueError, PortRange, '-1000/-3')
150		self.assertRaises(ValueError, PortRange, '-3/-1000')
151		self.assertRaises(ValueError, PortRange, ' - 24')
152		self.assertRaises(ValueError, PortRange, ' - 24 / 3')
153		self.assertRaises(ValueError, PortRange, ' 1024 / - 3')
154		self.assertRaises(ValueError, PortRange, ' - 1000 / - 3')
155		self.assertRaises(ValueError, PortRange, ' - 3/ - 1000 ')
156
157		# Test maximums and minimums
158		self.assertRaises(ValueError, PortRange, '1024/0')
159		self.assertRaises(ValueError, PortRange, '1024/17')
160		self.assertRaises(ValueError, PortRange, '10-66666', strict=True)
161
162		# Test capping.
163		self.assertEqual(PortRange('0').bounds, (1, 1))
164		self.assertRaises(ValueError, PortRange, '0', True)
165		self.assertEqual(PortRange('66666').bounds, (65535, 65535))
166		self.assertRaises(ValueError, PortRange, '66666', True)
167
168		# Test notation
169		self.assertRaises(ValueError, PortRange, '23/')
170		self.assertRaises(ValueError, PortRange, '/4')
171		self.assertRaises(ValueError, PortRange, '/4')
172		self.assertRaises(ValueError, PortRange, '400-')
173		self.assertRaises(ValueError, PortRange, '123 / 123/ 123')
174		self.assertRaises(ValueError, PortRange, ' 123 - 31123- 1323')
175
176		def test_strict_mode(self):
177		# Test power of two port base
178		PortRange('257', strict=True)
179		PortRange('257/16', strict=True)
180		self.assertRaises(ValueError, PortRange, '257/4', strict=True)
181
182		# Test overflowing upper bound
183		self.assertRaises(ValueError, PortRange, '65535/8', strict=True)
184
185		def test_computation(self):
186		self.assertEqual(PortRange('2/3').bounds, (2, 8193))
187		self.assertEqual(PortRange('7/3').bounds, (7, 8198))
188

scaleway / port-range

Push — develop ( b7d53e...9f91db )

TestPortRange A

Complexity

Size/Duplication

Importance

11 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like