TestPortRange.test_strict_range_parsing() - Code Metrics - scaleway/port-range - Measure and Improve Code Quality continuously with Scrutinizer

TestPortRange.test_strict_range_parsing() B
last analyzed 2017-08-02 09:28 UTC

↳ Parent: TestPortRange

Complexity

Conditions

Size

Total Lines

Duplication

Lines	23
Ratio	79.31 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
c	2
b	0
f	0
dl	23
loc	29
rs	8.8571

# -*- 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 length.
        self.assertRaises(ValueError, PortRange, [None, 42])
        self.assertRaises(ValueError, PortRange, [42, None])
        self.assertRaises(ValueError, PortRange, [42, 32, 3])
        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 length.
        self.assertRaises(ValueError, PortRange, [None, 42], True)
        self.assertRaises(ValueError, PortRange, [42, None], True)
        self.assertRaises(ValueError, PortRange, [42, 32, 3], 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 length.
49		self.assertRaises(ValueError, PortRange, [None, 42])
50		self.assertRaises(ValueError, PortRange, [42, None])
51		self.assertRaises(ValueError, PortRange, [42, 32, 3])
52		self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4])
53	View Code Duplication
		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		def test_strict_range_parsing(self):
55		# Normal range.
56		self.assertEqual(
57		PortRange('42-4242', strict=True).bounds, (42, 4242))
58		self.assertEqual(
59		PortRange([42, 4242], strict=True).bounds, (42, 4242))
60		self.assertEqual(
61		PortRange(['42', '4242'], strict=True).bounds, (42, 4242))
62
63		# Single port.
64		self.assertEqual(PortRange('42', strict=True).bounds, (42, 42))
65	View Code Duplication	self.assertEqual(PortRange(42, strict=True).bounds, (42, 42))
		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.assertEqual(PortRange([42], strict=True).bounds, (42, 42))
67		self.assertEqual(PortRange(['42'], strict=True).bounds, (42, 42))
68
69		# Reversed order.
70		self.assertRaises(ValueError, PortRange, [4242, 42], True)
71		self.assertRaises(ValueError, PortRange, '4242-42', True)
72		self.assertRaises(ValueError, PortRange, (4242, 42), True)
73		self.assertRaises(ValueError, PortRange, ('4242', '42'), True)
74		# Casting a set to a list might ends up with a naturally sorted list.
75		# self.assertRaises(ValueError, PortRange, set([4242, 42]), True)
76		# self.assertRaises(ValueError, PortRange, set(['4242', '42']), True)
77
78		# Invalid types and length.
79		self.assertRaises(ValueError, PortRange, [None, 42], True)
80		self.assertRaises(ValueError, PortRange, [42, None], True)
81		self.assertRaises(ValueError, PortRange, [42, 32, 3], True)
82		self.assertRaises(ValueError, PortRange, [42, None, 32, 3, -4], True)
83
84		def test_cidr_properties(self):
85		port = PortRange('1027/15')
86		self.assertEqual(port.base, 1027)
87		self.assertEqual(port.prefix, 15)
88		self.assertEqual(port.cidr, (1027, 15))
89		self.assertEqual(port.mask, 1)
90		self.assertEqual(port.offset, 3)
91		self.assertEqual(port.port_from, 1027)
92		self.assertEqual(port.port_to, 1028)
93		self.assertEqual(port.bounds, (1027, 1028))
94
95		def test_range_properties(self):
96		port = PortRange([4242, 42])
97		self.assertEqual(str(port), '42-4242')
98		self.assertEqual(port.base, 42)
99		self.assertEqual(port.prefix, None)
100		self.assertEqual(port.cidr, (42, None))
101		self.assertEqual(port.mask, None)
102		self.assertEqual(port.offset, 10)
103		self.assertEqual(port.port_from, 42)
104		self.assertEqual(port.port_to, 4242)
105		self.assertEqual(port.bounds, (42, 4242))
106
107		def test_normalization(self):
108		port = PortRange(' 0001234 ')
109		self.assertEqual(str(port), '1234')
110		self.assertEqual(port.base, 1234)
111		self.assertEqual(port.prefix, 16)
112		self.assertEqual(port.cidr, (1234, 16))
113		self.assertEqual(port.mask, 0)
114		self.assertEqual(port.offset, 210)
115		self.assertEqual(port.port_from, 1234)
116		self.assertEqual(port.port_to, 1234)
117		self.assertEqual(port.bounds, (1234, 1234))
118
119		# Upper-bound cap.
120		self.assertEqual(PortRange('64666/3').bounds, (64666, 65535))
121
122		def test_output_string(self):
123		self.assertEqual(str(PortRange('1027/15')), '1027/15')
124		self.assertEqual(str(PortRange([42, 4242])), '42-4242')
125		self.assertEqual(str(PortRange(42)), '42')
126		self.assertEqual(str(PortRange([1027, 1028])), '1027/15')
127
128		self.assertEqual(
129		repr(PortRange([1027, 1028])),
130		"PortRange(port_from=1027, port_to=1028, base=1027, offset=3, "
131		"prefix=15, mask=1, is_single_port=False, is_cidr=True)")
132
133		def test_cidr_string_rendering(self):
134		self.assertEqual(PortRange([32768, 65535]).cidr_string, '32768/1')
135		self.assertEqual(PortRange([32767, 65534]).cidr_string, '32767/1')
136		with self.assertRaises(ValueError):
137		PortRange([32767, 65535]).cidr_string
138
139		def test_validation(self):
140		# Test empty params
141		self.assertRaises(ValueError, PortRange, None)
142		self.assertRaises(ValueError, PortRange, [None])
143		self.assertRaises(ValueError, PortRange, [None, None])
144
145		# Invalid int
146		self.assertRaises(ValueError, PortRange, ' A233 ')
147		self.assertRaises(ValueError, PortRange, '1 2 3 4')
148		self.assertRaises(ValueError, PortRange, 'abcd')
149
150		# Test negative values
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		self.assertRaises(ValueError, PortRange, ' - 24')
157		self.assertRaises(ValueError, PortRange, ' - 24 / 3')
158		self.assertRaises(ValueError, PortRange, ' 1024 / - 3')
159		self.assertRaises(ValueError, PortRange, ' - 1000 / - 3')
160		self.assertRaises(ValueError, PortRange, ' - 3/ - 1000 ')
161
162		# Test maximums and minimums
163		self.assertRaises(ValueError, PortRange, '1024/0')
164		self.assertRaises(ValueError, PortRange, '1024/17')
165		self.assertRaises(ValueError, PortRange, '10-66666', strict=True)
166
167		# Test capping.
168		self.assertEqual(PortRange('0').bounds, (1, 1))
169		self.assertRaises(ValueError, PortRange, '0', True)
170		self.assertEqual(PortRange('66666').bounds, (65535, 65535))
171		self.assertRaises(ValueError, PortRange, '66666', True)
172
173		# Test notation
174		self.assertRaises(ValueError, PortRange, '23/')
175		self.assertRaises(ValueError, PortRange, '/4')
176		self.assertRaises(ValueError, PortRange, '/4')
177		self.assertRaises(ValueError, PortRange, '400-')
178		self.assertRaises(ValueError, PortRange, '123 / 123/ 123')
179		self.assertRaises(ValueError, PortRange, ' 123 - 31123- 1323')
180
181		def test_strict_mode(self):
182		# Test power of two port base
183		PortRange('257', strict=True)
184		PortRange('257/16', strict=True)
185		self.assertRaises(ValueError, PortRange, '257/4', strict=True)
186
187		# Test overflowing upper bound
188		self.assertRaises(ValueError, PortRange, '65535/8', strict=True)
189
190		def test_computation(self):
191		self.assertEqual(PortRange('2/3').bounds, (2, 8193))
192		self.assertEqual(PortRange('7/3').bounds, (7, 8198))
193

scaleway / port-range

TestPortRange.test_strict_range_parsing() B last analyzed 2017-08-02 09:28 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TestPortRange.test_strict_range_parsing() B
last analyzed 2017-08-02 09:28 UTC