build.tests.unit.test_search_results3.TestSearchResults3.generate_topology() - Code Metrics - Inspection of "Logic Changes" - kytos/pathfinder - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#58)

unknown

created 2020-06-17 20:42 UTC

TestSearchResults3.generate_topology() B

↳ Parent: build.tests.unit.test_search_results3

Complexity

Conditions

Size

Total Lines	60
Code Lines	51

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	51
nop	0
dl	0
loc	60
rs	8.6036
c	0
b	0
f	0

How to fix Long Method

"""Module to test the KytosGraph in graph.py."""
from unittest import TestCase
from unittest.mock import Mock

import networkx as nx
from kytos.core.interface import Interface
from kytos.core.link import Link
# Core modules to import
from kytos.core.switch import Switch

# module under test
from graph import KytosGraph
from tests.unit.test_search_results import TestSearchResults


class TestSearchResults3(TestSearchResults):
    '''Tests for the graph class.'''

    def test_path9(self):
        """Tests to see if an illegal path is not in the set of paths that
        use only edges owned by A."""
        # Arrange
        self.test_setup()
        illegal_path = ['User1', 'User1:1', 'S2:1',
                        'S2', 'S2:2', 'User2:1', 'User2']
        # Act
        result = self.get_path_constrained("User1", "User2", 0, ownership='A')
        # Assert
        self.assertNotIn(illegal_path, result[0]["paths"])

    def test_path10(self):
        """Tests to see if the edges used in the paths of the result set
        do not have poor reliability"""
        # Arrange
        self.test_setup()
        reliabilities = []
        poor_reliability = 1
        key = "reliability"

        # Act
        result = self.get_path_constrained("User1", "User2", 0, reliability=3)

        if result:
            for path in result[0]["paths"]:
                for i in range(1, len(path)):
                    endpoint_a = path[i - 1]
                    endpoint_b = path[i]
                    meta_data = self.graph.get_metadata_from_link(
                        endpoint_a, endpoint_b)
                    if meta_data and key in meta_data.keys():
                        reliabilities.append(meta_data[key])

        # Assert
        self.assertNotIn(poor_reliability, reliabilities)

    def test_path11(self):
        """Tests to see if the edges used in the paths from User 1 to User 2
        have less than 30 delay."""
        # Arrange
        self.test_setup()
        delays = []
        delay_cap = 29
        key = "delay"
        has_bad_delay = False

        # Act
        result = self.get_path_constrained(
            "User1", "User2", 0, delay=delay_cap)

        if result:
            for path in result[0]["paths"]:
                for i in range(1, len(path)):
                    endpoint_a = path[i - 1]
                    endpoint_b = path[i]
                    meta_data = self.graph.get_metadata_from_link(
                        endpoint_a, endpoint_b)
                    if meta_data and key in meta_data.keys():
                        delays.append(meta_data[key])

        # Assert
        for delay in delays:
            has_bad_delay = delay > delay_cap
            self.assertEqual(has_bad_delay, False)

    def test_path12(self):
        """Tests to see if the edges used in the paths from User 1 to User 2
        have at least 20 bandwidth."""
        # Arrange
        self.test_setup()
        bandwidths = []
        bandwidth_floor = 20
        key = "bandwidth"
        has_bad_bandwidth = False

        # Act
        result = self.get_path_constrained(
            "User1", "User2", 0, bandwidth=bandwidth_floor)

        if result:
            for path in result[0]["paths"]:
                for i in range(1, len(path)):
                    endpoint_a = path[i - 1]
                    endpoint_b = path[i]
                    meta_data = self.graph.get_metadata_from_link(
                        endpoint_a, endpoint_b)
                    if meta_data and key in meta_data.keys():
                        bandwidths.append(meta_data[key])

        # Assert
        for bandwidth in bandwidths:
            has_bad_bandwidth = bandwidth < bandwidth_floor
            self.assertEqual(has_bad_bandwidth, False)

    def test_path13(self):
        """Tests to see if the edges used in the paths from User 1 to User 2
        have at least 20 bandwidth and under 30 delay."""
        # Arrange
        self.test_setup()
        bandwidths = []
        delays = []
        bandwidth_floor = 20
        key_a = "bandwidth"
        delay_cap = 29
        key_b = "delay"
        has_bad_bandwidth = False
        has_bad_delay = False

        # Act
        result = self.get_path_constrained(
            "User1", "User2", 0, bandwidth=bandwidth_floor, delay=delay_cap)

        if result:
            for path in result[0]["paths"]:
                for i in range(1, len(path)):
                    endpoint_a = path[i - 1]
                    endpoint_b = path[i]
                    meta_data = self.graph.get_metadata_from_link(
                        endpoint_a, endpoint_b)
                    if meta_data and key_a in meta_data.keys():
                        bandwidths.append(meta_data[key_a])
                    elif meta_data and key_b in meta_data.keys():
                        delays.append(meta_data[key_b])

        # Assert
        for bandwidth in bandwidths:
            has_bad_bandwidth = bandwidth < bandwidth_floor
            self.assertEqual(has_bad_bandwidth, False)

        for delay in delays:
            has_bad_delay = delay > delay_cap
            self.assertEqual(has_bad_delay, False)

    @staticmethod
    def generate_topology():
        """Generates a predetermined topology"""
        switches = {}
        interfaces = {}
        links = {}

        TestSearchResults.create_switch("User1", switches)
        TestSearchResults.add_interfaces(3, switches["User1"], interfaces)

        TestSearchResults.create_switch("S2", switches)
        TestSearchResults.add_interfaces(2, switches["S2"], interfaces)

        TestSearchResults.create_switch("User2", switches)
        TestSearchResults.add_interfaces(3, switches["User2"], interfaces)

        TestSearchResults.create_switch("S4", switches)
        TestSearchResults.add_interfaces(4, switches["S4"], interfaces)

        TestSearchResults.create_switch("S5", switches)
        TestSearchResults.add_interfaces(2, switches["S5"], interfaces)

        TestSearchResults.create_link("User1:1", "S2:1", interfaces, links)
        TestSearchResults.create_link("User1:2", "S5:1", interfaces, links)
        TestSearchResults.create_link("User1:3", "S4:1", interfaces, links)
        TestSearchResults.create_link("S2:2", "User2:1", interfaces, links)
        TestSearchResults.create_link("User2:2", "S4:2", interfaces, links)
        TestSearchResults.create_link("S5:2", "S4:3", interfaces, links)
        TestSearchResults.create_link("User2:3", "S4:4", interfaces, links)

        TestSearchResults.add_metadata_to_link(
            "User1:1", "S2:1", {
                "reliability": 3, "ownership": "B", "delay": 30,
                "bandwidth": 20}, links)
        TestSearchResults.add_metadata_to_link(
            "User1:2", "S5:1", {
                "reliability": 1, "ownership": "A", "delay": 5,
                "bandwidth": 50}, links)
        TestSearchResults.add_metadata_to_link(
            "User1:3", "S4:1", {
                "reliability": 3, "ownership": "A", "delay": 60,
                "bandwidth": 10}, links)
        TestSearchResults.add_metadata_to_link(
            "S2:2", "User2:1", {
                "reliability": 3, "ownership": "B", "delay": 30,
                "bandwidth": 20}, links)
        TestSearchResults.add_metadata_to_link(
            "User2:2", "S4:2", {
                "reliability": 3, "ownership": "B", "delay": 30,
                "bandwidth": 10}, links)
        TestSearchResults.add_metadata_to_link(
            "S5:2", "S4:3", {
                "reliability": 1, "ownership": "A", "delay": 10,
                "bandwidth": 50}, links)
        TestSearchResults.add_metadata_to_link(
            "User2:3", "S4:4", {
                "reliability": 3, "ownership": "A", "delay": 29,
                "bandwidth": 20}, links)

        return (switches, links)


1			"""Module to test the KytosGraph in graph.py."""
2			from unittest import TestCase
3			from unittest.mock import Mock
4
5			import networkx as nx
6			from kytos.core.interface import Interface
7			from kytos.core.link import Link
8			# Core modules to import
9			from kytos.core.switch import Switch
10
11			# module under test
12			from graph import KytosGraph
13			from tests.unit.test_search_results import TestSearchResults
14
15
16			class TestSearchResults3(TestSearchResults):
17			'''Tests for the graph class.'''
18
19			def test_path9(self):
20			"""Tests to see if an illegal path is not in the set of paths that
21			use only edges owned by A."""
22			# Arrange
23			self.test_setup()
24			illegal_path = ['User1', 'User1:1', 'S2:1',
25			'S2', 'S2:2', 'User2:1', 'User2']
26			# Act
27			result = self.get_path_constrained("User1", "User2", 0, ownership='A')
28			# Assert
29			self.assertNotIn(illegal_path, result[0]["paths"])
30
31			def test_path10(self):
32			"""Tests to see if the edges used in the paths of the result set
33			do not have poor reliability"""
34			# Arrange
35			self.test_setup()
36			reliabilities = []
37			poor_reliability = 1
38			key = "reliability"
39
40			# Act
41			result = self.get_path_constrained("User1", "User2", 0, reliability=3)
42
43			if result:
44			for path in result[0]["paths"]:
45			for i in range(1, len(path)):
46			endpoint_a = path[i - 1]
47			endpoint_b = path[i]
48			meta_data = self.graph.get_metadata_from_link(
49			endpoint_a, endpoint_b)
50			if meta_data and key in meta_data.keys():
51			reliabilities.append(meta_data[key])
52
53			# Assert
54			self.assertNotIn(poor_reliability, reliabilities)
55
56			def test_path11(self):
57			"""Tests to see if the edges used in the paths from User 1 to User 2
58			have less than 30 delay."""
59			# Arrange
60			self.test_setup()
61			delays = []
62			delay_cap = 29
63			key = "delay"
64			has_bad_delay = False
65
66			# Act
67			result = self.get_path_constrained(
68			"User1", "User2", 0, delay=delay_cap)
69
70			if result:
71			for path in result[0]["paths"]:
72			for i in range(1, len(path)):
73			endpoint_a = path[i - 1]
74			endpoint_b = path[i]
75			meta_data = self.graph.get_metadata_from_link(
76			endpoint_a, endpoint_b)
77			if meta_data and key in meta_data.keys():
78			delays.append(meta_data[key])
79
80			# Assert
81			for delay in delays:
82			has_bad_delay = delay > delay_cap
83			self.assertEqual(has_bad_delay, False)
84
85			def test_path12(self):
86			"""Tests to see if the edges used in the paths from User 1 to User 2
87			have at least 20 bandwidth."""
88			# Arrange
89			self.test_setup()
90			bandwidths = []
91			bandwidth_floor = 20
92			key = "bandwidth"
93			has_bad_bandwidth = False
94
95			# Act
96			result = self.get_path_constrained(
97			"User1", "User2", 0, bandwidth=bandwidth_floor)
98
99			if result:
100			for path in result[0]["paths"]:
101			for i in range(1, len(path)):
102			endpoint_a = path[i - 1]
103			endpoint_b = path[i]
104			meta_data = self.graph.get_metadata_from_link(
105			endpoint_a, endpoint_b)
106			if meta_data and key in meta_data.keys():
107			bandwidths.append(meta_data[key])
108
109			# Assert
110			for bandwidth in bandwidths:
111			has_bad_bandwidth = bandwidth < bandwidth_floor
112			self.assertEqual(has_bad_bandwidth, False)
113
114			def test_path13(self):
115			"""Tests to see if the edges used in the paths from User 1 to User 2
116			have at least 20 bandwidth and under 30 delay."""
117			# Arrange
118			self.test_setup()
119			bandwidths = []
120			delays = []
121			bandwidth_floor = 20
122			key_a = "bandwidth"
123			delay_cap = 29
124			key_b = "delay"
125			has_bad_bandwidth = False
126			has_bad_delay = False
127
128			# Act
129			result = self.get_path_constrained(
130			"User1", "User2", 0, bandwidth=bandwidth_floor, delay=delay_cap)
131
132			if result:
133			for path in result[0]["paths"]:
134			for i in range(1, len(path)):
135			endpoint_a = path[i - 1]
136			endpoint_b = path[i]
137			meta_data = self.graph.get_metadata_from_link(
138			endpoint_a, endpoint_b)
139			if meta_data and key_a in meta_data.keys():
140			bandwidths.append(meta_data[key_a])
141			elif meta_data and key_b in meta_data.keys():
142			delays.append(meta_data[key_b])
143
144			# Assert
145			for bandwidth in bandwidths:
146			has_bad_bandwidth = bandwidth < bandwidth_floor
147			self.assertEqual(has_bad_bandwidth, False)
148
149			for delay in delays:
150			has_bad_delay = delay > delay_cap
151			self.assertEqual(has_bad_delay, False)
152
153			@staticmethod
154			def generate_topology():
155			"""Generates a predetermined topology"""
156			switches = {}
157			interfaces = {}
158			links = {}
159
160			TestSearchResults.create_switch("User1", switches)
161			TestSearchResults.add_interfaces(3, switches["User1"], interfaces)
162
163			TestSearchResults.create_switch("S2", switches)
164			TestSearchResults.add_interfaces(2, switches["S2"], interfaces)
165
166			TestSearchResults.create_switch("User2", switches)
167			TestSearchResults.add_interfaces(3, switches["User2"], interfaces)
168
169			TestSearchResults.create_switch("S4", switches)
170			TestSearchResults.add_interfaces(4, switches["S4"], interfaces)
171
172			TestSearchResults.create_switch("S5", switches)
173			TestSearchResults.add_interfaces(2, switches["S5"], interfaces)
174
175			TestSearchResults.create_link("User1:1", "S2:1", interfaces, links)
176			TestSearchResults.create_link("User1:2", "S5:1", interfaces, links)
177			TestSearchResults.create_link("User1:3", "S4:1", interfaces, links)
178			TestSearchResults.create_link("S2:2", "User2:1", interfaces, links)
179			TestSearchResults.create_link("User2:2", "S4:2", interfaces, links)
180			TestSearchResults.create_link("S5:2", "S4:3", interfaces, links)
181			TestSearchResults.create_link("User2:3", "S4:4", interfaces, links)
182
183			TestSearchResults.add_metadata_to_link(
184			"User1:1", "S2:1", {
185			"reliability": 3, "ownership": "B", "delay": 30,
186			"bandwidth": 20}, links)
187			TestSearchResults.add_metadata_to_link(
188			"User1:2", "S5:1", {
189			"reliability": 1, "ownership": "A", "delay": 5,
190			"bandwidth": 50}, links)
191			TestSearchResults.add_metadata_to_link(
192			"User1:3", "S4:1", {
193			"reliability": 3, "ownership": "A", "delay": 60,
194			"bandwidth": 10}, links)
195			TestSearchResults.add_metadata_to_link(
196			"S2:2", "User2:1", {
197			"reliability": 3, "ownership": "B", "delay": 30,
198			"bandwidth": 20}, links)
199			TestSearchResults.add_metadata_to_link(
200			"User2:2", "S4:2", {
201			"reliability": 3, "ownership": "B", "delay": 30,
202			"bandwidth": 10}, links)
203			TestSearchResults.add_metadata_to_link(
204			"S5:2", "S4:3", {
205			"reliability": 1, "ownership": "A", "delay": 10,
206			"bandwidth": 50}, links)
207			TestSearchResults.add_metadata_to_link(
208			"User2:3", "S4:4", {
209			"reliability": 3, "ownership": "A", "delay": 29,
210			"bandwidth": 20}, links)
211
212			return (switches, links)
213

kytos / pathfinder

Pull Request — master (#58)

TestSearchResults3.generate_topology() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like