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

Completed

Pull Request — master (#58)

unknown

created 2020-06-17 21:03 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."""

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

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