build.tests.models.test_evc_base.TestEVC.test_as_dict() - Code Metrics - Inspection of "Implement link protection" - kytos/mef_eline - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#54)

by macartur

created 2018-08-30 17:33 UTC

TestEVC.test_as_dict() B

↳ Parent: build.tests.models.test_evc_base

Complexity

Conditions

Size

Total Lines	64
Code Lines	59

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	59
nop	1
dl	0
loc	64
rs	7.8751
c	0
b	0
f	0

How to fix Long Method

"""Module to test the EVCBase class."""
import sys
from unittest import TestCase

from kytos.core.interface import UNI

# pylint: disable=wrong-import-position
sys.path.insert(0, '/var/lib/kytos/napps/..')
# pylint: enable=wrong-import-position

from napps.kytos.mef_eline.models import EVC  # NOQA
from napps.kytos.mef_eline.tests.helpers import get_uni_mocked  # NOQA


class TestEVC(TestCase):  # pylint: disable=too-many-public-methods
    """Tests to verify EVC class."""

    def test_attributes_empty(self):
        """Test if the EVC raises an error with name is required."""
        attributes = {}
        error_message = "name is required."
        with self.assertRaises(ValueError) as handle_error:
            EVC(**attributes)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_without_uni_a(self):
        """Test if the EVC raises and error with UNI A is required."""
        attributes = {"name": "circuit_name"}
        error_message = "uni_a is required."
        with self.assertRaises(ValueError) as handle_error:
            EVC(**attributes)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_with_invalid_uni_a(self):
        """Test if the EVC raises and error with invalid UNI A."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(tag_value=82)
        }
        error_message = "VLAN tag 82 is not available in uni_a"
        with self.assertRaises(ValueError) as handle_error:
            EVC(**attributes)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_without_uni_z(self):
        """Test if the EVC raises and error with UNI Z is required."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True)
        }
        error_message = "uni_z is required."
        with self.assertRaises(ValueError) as handle_error:
            EVC(**attributes)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_with_invalid_uni_z(self):
        """Test if the EVC raises and error with UNI Z is required."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(tag_value=83)
        }
        error_message = "VLAN tag 83 is not available in uni_z"
        with self.assertRaises(ValueError) as handle_error:
            EVC(**attributes)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_update_name(self):

        """Test if raises and error when trying to update the name."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        update_dict = {
            "name": "circuit_name_2"
        }
        error_message = "name can't be be updated."
        with self.assertRaises(ValueError) as handle_error:
            evc = EVC(**attributes)
            evc.update(**update_dict)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_update_uni_a(self):

        """Test if raises and error when trying to update the uni_a."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        update_dict = {
            "uni_a": get_uni_mocked(is_valid=True)
        }
        error_message = "uni_a can't be be updated."
        with self.assertRaises(ValueError) as handle_error:
            evc = EVC(**attributes)
            evc.update(**update_dict)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_update_uni_z(self):

        """Test if raises and error when trying to update the uni_z."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        update_dict = {
            "uni_z": get_uni_mocked(is_valid=True)
        }
        error_message = "uni_z can't be be updated."
        with self.assertRaises(ValueError) as handle_error:
            evc = EVC(**attributes)
            evc.update(**update_dict)
        self.assertEqual(str(handle_error.exception), error_message)

    def test_circuit_representation(self):
        """Test the method __repr__."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        evc = EVC(**attributes)
        expected_value = f'EVC({evc.id}, {evc.name})'
        self.assertEqual(str(evc), expected_value)

    def test_comparison_method(self):
        """Test the method __eq__."""
        attributes = {
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        evc1 = EVC(**attributes)
        evc2 = EVC(**attributes)

        attributes = {
            "name": "circuit_name_2",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        evc3 = EVC(**attributes)
        evc4 = EVC(**attributes)

        self.assertEqual(evc1 == evc2, True)
        self.assertEqual(evc1 == evc3, False)
        self.assertEqual(evc2 == evc3, False)
        self.assertEqual(evc3 == evc4, True)

    def test_as_dict(self):
        """Test the method as_dict."""
        attributes = {
            "id": "custom_id",
            "name": "custom_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "start_date": '2018-08-21T18:44:54',
            "end_date": '2018-08-21T18:44:55',
            'primary_links': [],
            'request_time': '2018-08-21T19:10:41',
            'creation_time': '2018-08-21T18:44:54',
            'owner': "my_name",
            'circuit_scheduler': [],
            'enabled': True,
            'priority': 2
        }
        evc = EVC(**attributes)

        expected_dict = {
            'id': 'custom_id',
            'name': 'custom_name',
            'uni_a': attributes['uni_a'].as_dict(),
            'uni_z': attributes['uni_z'].as_dict(),
            'start_date': '2018-08-21T18:44:54',
            'end_date': '2018-08-21T18:44:55',
            'bandwidth': 0,
            'primary_links': [],
            'backup_links': [],
            'current_path': [],
            'primary_path': [],
            'backup_path': [],
            'dynamic_backup_path': False,
            '_requested': {
                           "id": "custom_id",
                           "name": "custom_name",
                           "uni_a": attributes['uni_a'].as_dict(),
                           "uni_z": attributes['uni_z'].as_dict(),
                           "start_date": '2018-08-21T18:44:54',
                           "end_date": '2018-08-21T18:44:55',
                           'primary_links': [],
                           'request_time': '2018-08-21T19:10:41',
                           'creation_time': '2018-08-21T18:44:54',
                           'owner': "my_name",
                           'circuit_scheduler': [],
                           'enabled': True,
                           'priority': 2
            },
            'request_time': '2018-08-21T19:10:41',
            'creation_time': '2018-08-21T18:44:54',
            'owner': 'my_name',
            'circuit_scheduler': [],
            'active': False,
            'enabled': True,
            'priority': 2
        }
        actual_dict = evc.as_dict()
        for name, value in expected_dict.items():
            actual = actual_dict.get(name)
            if name == '_requested':
                for requested_name, requested_value in value.items():
                    if isinstance(requested_value, UNI):
                        value[requested_name] = requested_value.as_dict()
            self.assertEqual(value, actual)


1		"""Module to test the EVCBase class."""
2		import sys
3		from unittest import TestCase
4
5		from kytos.core.interface import UNI
6
7		# pylint: disable=wrong-import-position
8		sys.path.insert(0, '/var/lib/kytos/napps/..')
9		# pylint: enable=wrong-import-position
10
11		from napps.kytos.mef_eline.models import EVC # NOQA
12		from napps.kytos.mef_eline.tests.helpers import get_uni_mocked # NOQA
13
14
15		class TestEVC(TestCase): # pylint: disable=too-many-public-methods
16		"""Tests to verify EVC class."""
17
18		def test_attributes_empty(self):
19		"""Test if the EVC raises an error with name is required."""
20		attributes = {}
21		error_message = "name is required."
22		with self.assertRaises(ValueError) as handle_error:
23		EVC(**attributes)
24		self.assertEqual(str(handle_error.exception), error_message)
25
26		def test_without_uni_a(self):
27		"""Test if the EVC raises and error with UNI A is required."""
28		attributes = {"name": "circuit_name"}
29		error_message = "uni_a is required."
30		with self.assertRaises(ValueError) as handle_error:
31		EVC(**attributes)
32		self.assertEqual(str(handle_error.exception), error_message)
33
34		def test_with_invalid_uni_a(self):
35		"""Test if the EVC raises and error with invalid UNI A."""
36		attributes = {
37		"name": "circuit_name",
38		"uni_a": get_uni_mocked(tag_value=82)
39		}
40		error_message = "VLAN tag 82 is not available in uni_a"
41		with self.assertRaises(ValueError) as handle_error:
42		EVC(**attributes)
43		self.assertEqual(str(handle_error.exception), error_message)
44
45		def test_without_uni_z(self):
46		"""Test if the EVC raises and error with UNI Z is required."""
47		attributes = {
48		"name": "circuit_name",
49		"uni_a": get_uni_mocked(is_valid=True)
50		}
51		error_message = "uni_z is required."
52		with self.assertRaises(ValueError) as handle_error:
53		EVC(**attributes)
54		self.assertEqual(str(handle_error.exception), error_message)
55
56		def test_with_invalid_uni_z(self):
57		"""Test if the EVC raises and error with UNI Z is required."""
58		attributes = {
59		"name": "circuit_name",
60		"uni_a": get_uni_mocked(is_valid=True),
61		"uni_z": get_uni_mocked(tag_value=83)
62		}
63		error_message = "VLAN tag 83 is not available in uni_z"
64		with self.assertRaises(ValueError) as handle_error:
65		EVC(**attributes)
66		self.assertEqual(str(handle_error.exception), error_message)
67
68	View Code Duplication	def test_update_name(self):
		0 ignored issues – show Duplication introduced 2018-08-30 17:36 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
69		"""Test if raises and error when trying to update the name."""
70		attributes = {
71		"name": "circuit_name",
72		"uni_a": get_uni_mocked(is_valid=True),
73		"uni_z": get_uni_mocked(is_valid=True)
74		}
75		update_dict = {
76		"name": "circuit_name_2"
77		}
78		error_message = "name can't be be updated."
79		with self.assertRaises(ValueError) as handle_error:
80		evc = EVC(**attributes)
81		evc.update(**update_dict)
82		self.assertEqual(str(handle_error.exception), error_message)
83
84	View Code Duplication	def test_update_uni_a(self):
		0 ignored issues – show Duplication introduced 2018-08-28 17:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
85		"""Test if raises and error when trying to update the uni_a."""
86		attributes = {
87		"name": "circuit_name",
88		"uni_a": get_uni_mocked(is_valid=True),
89		"uni_z": get_uni_mocked(is_valid=True)
90		}
91		update_dict = {
92		"uni_a": get_uni_mocked(is_valid=True)
93		}
94		error_message = "uni_a can't be be updated."
95		with self.assertRaises(ValueError) as handle_error:
96		evc = EVC(**attributes)
97		evc.update(**update_dict)
98		self.assertEqual(str(handle_error.exception), error_message)
99
100	View Code Duplication	def test_update_uni_z(self):
		0 ignored issues – show Duplication introduced 2018-08-28 17:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
101		"""Test if raises and error when trying to update the uni_z."""
102		attributes = {
103		"name": "circuit_name",
104		"uni_a": get_uni_mocked(is_valid=True),
105		"uni_z": get_uni_mocked(is_valid=True)
106		}
107		update_dict = {
108		"uni_z": get_uni_mocked(is_valid=True)
109		}
110		error_message = "uni_z can't be be updated."
111		with self.assertRaises(ValueError) as handle_error:
112		evc = EVC(**attributes)
113		evc.update(**update_dict)
114		self.assertEqual(str(handle_error.exception), error_message)
115
116		def test_circuit_representation(self):
117		"""Test the method __repr__."""
118		attributes = {
119		"name": "circuit_name",
120		"uni_a": get_uni_mocked(is_valid=True),
121		"uni_z": get_uni_mocked(is_valid=True)
122		}
123		evc = EVC(**attributes)
124		expected_value = f'EVC({evc.id}, {evc.name})'
125		self.assertEqual(str(evc), expected_value)
126
127		def test_comparison_method(self):
128		"""Test the method __eq__."""
129		attributes = {
130		"name": "circuit_name",
131		"uni_a": get_uni_mocked(is_valid=True),
132		"uni_z": get_uni_mocked(is_valid=True)
133		}
134		evc1 = EVC(**attributes)
135		evc2 = EVC(**attributes)
136
137		attributes = {
138		"name": "circuit_name_2",
139		"uni_a": get_uni_mocked(is_valid=True),
140		"uni_z": get_uni_mocked(is_valid=True)
141		}
142		evc3 = EVC(**attributes)
143		evc4 = EVC(**attributes)
144
145		self.assertEqual(evc1 == evc2, True)
146		self.assertEqual(evc1 == evc3, False)
147		self.assertEqual(evc2 == evc3, False)
148		self.assertEqual(evc3 == evc4, True)
149
150		def test_as_dict(self):
151		"""Test the method as_dict."""
152		attributes = {
153		"id": "custom_id",
154		"name": "custom_name",
155		"uni_a": get_uni_mocked(is_valid=True),
156		"uni_z": get_uni_mocked(is_valid=True),
157		"start_date": '2018-08-21T18:44:54',
158		"end_date": '2018-08-21T18:44:55',
159		'primary_links': [],
160		'request_time': '2018-08-21T19:10:41',
161		'creation_time': '2018-08-21T18:44:54',
162		'owner': "my_name",
163		'circuit_scheduler': [],
164		'enabled': True,
165		'priority': 2
166		}
167		evc = EVC(**attributes)
168
169		expected_dict = {
170		'id': 'custom_id',
171		'name': 'custom_name',
172		'uni_a': attributes['uni_a'].as_dict(),
173		'uni_z': attributes['uni_z'].as_dict(),
174		'start_date': '2018-08-21T18:44:54',
175		'end_date': '2018-08-21T18:44:55',
176		'bandwidth': 0,
177		'primary_links': [],
178		'backup_links': [],
179		'current_path': [],
180		'primary_path': [],
181		'backup_path': [],
182		'dynamic_backup_path': False,
183		'_requested': {
184		"id": "custom_id",
185		"name": "custom_name",
186		"uni_a": attributes['uni_a'].as_dict(),
187		"uni_z": attributes['uni_z'].as_dict(),
188		"start_date": '2018-08-21T18:44:54',
189		"end_date": '2018-08-21T18:44:55',
190		'primary_links': [],
191		'request_time': '2018-08-21T19:10:41',
192		'creation_time': '2018-08-21T18:44:54',
193		'owner': "my_name",
194		'circuit_scheduler': [],
195		'enabled': True,
196		'priority': 2
197		},
198		'request_time': '2018-08-21T19:10:41',
199		'creation_time': '2018-08-21T18:44:54',
200		'owner': 'my_name',
201		'circuit_scheduler': [],
202		'active': False,
203		'enabled': True,
204		'priority': 2
205		}
206		actual_dict = evc.as_dict()
207		for name, value in expected_dict.items():
208		actual = actual_dict.get(name)
209		if name == '_requested':
210		for requested_name, requested_value in value.items():
211		if isinstance(requested_value, UNI):
212		value[requested_name] = requested_value.as_dict()
213		self.assertEqual(value, actual)
214

kytos / mef_eline

Pull Request — master (#54)

TestEVC.test_as_dict() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like