build.tests.unit.test_search_results2.TestSearchResults2.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

TestSearchResults2.generate_topology() B

↳ Parent: build.tests.unit.test_search_results2

Complexity

Conditions

Size

Total Lines	175
Code Lines	131

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	131
nop	0
dl	0
loc	175
rs	7
c	0
b	0
f	0

How to fix Long Method

"""Module to test the KytosGraph in graph.py."""
from itertools import combinations

# Core modules to import
from kytos.core.link import Link

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


class TestSearchResults2(TestSearchResults):
    """Tests for the graph class."""

    def test_path1(self):
        """Tests paths between all users using unconstrained path alogrithm."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path(point_a, point_b)
            self.assertNotEqual(results, [])

    def test_path2(self):
        """Tests paths between all users using constrained path algorithm,
        with no constraints set."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(point_a, point_b)
            self.assertNotEqual(results, [])

    def test_path3(self):
        """Tests paths between all users using constrained path algorithm,
        with the ownership constraint set to B."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(
                point_a, point_b, 0, ownership="B")
            for result in results:
                for path in result["paths"]:
                    self.assertNotIn("S4:1", path)
                    self.assertNotIn("S5:2", path)
                    self.assertNotIn("S4:2", path)
                    self.assertNotIn("User1:2", path)
                    self.assertNotIn("S5:4", path)
                    self.assertNotIn("S6:2", path)
                    self.assertNotIn("S6:5", path)
                    self.assertNotIn("S10:1", path)
                    self.assertNotIn("S8:6", path)
                    self.assertNotIn("S10:2", path)
                    self.assertNotIn("S10:3", path)
                    self.assertNotIn("User2:1", path)

    def test_path4(self):
        """Tests paths between all users using constrained path algorithm,
        with the reliability constraint set to 3."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(
                point_a, point_b, 0, reliability=3)
            for result in results:
                for path in result["paths"]:
                    self.assertNotIn("S4:1", path)
                    self.assertNotIn("S5:2", path)
                    self.assertNotIn("S5:3", path)
                    self.assertNotIn("S6:1", path)

    def test_path5(self):
        """Tests paths between all users using constrained path algorithm,
        with the bandwidth contraint set to 100."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(
                point_a, point_b, 0, bandwidth=100)
            for result in results:
                for path in result["paths"]:
                    self.assertNotIn("S3:1", path)
                    self.assertNotIn("S5:1", path)
                    self.assertNotIn("User1:4", path)
                    self.assertNotIn("User4:3", path)

    def test_path6(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50."""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(point_a, point_b, 0, delay=50)
            for result in results:
                for path in result["paths"]:
                    self.assertNotIn("S1:1", path)
                    self.assertNotIn("S2:1", path)
                    self.assertNotIn("S3:1", path)
                    self.assertNotIn("S5:1", path)
                    self.assertNotIn("S4:2", path)
                    self.assertNotIn("User1:2", path)
                    self.assertNotIn("S5:5", path)
                    self.assertNotIn("S8:2", path)
                    self.assertNotIn("S5:6", path)
                    self.assertNotIn("User1:3", path)
                    self.assertNotIn("S6:3", path)
                    self.assertNotIn("S9:1", path)
                    self.assertNotIn("S6:4", path)
                    self.assertNotIn("S9:2", path)
                    self.assertNotIn("S6:5", path)
                    self.assertNotIn("S10:1", path)
                    self.assertNotIn("S8:5", path)
                    self.assertNotIn("S9:4", path)
                    self.assertNotIn("User1:4", path)
                    self.assertNotIn("User4:3", path)

    def test_path7(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint set
        to 100, the reliability contraint set to 3, and the ownership
        constraint set to 'B' """
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(
                point_a, point_b, 0, delay=50, bandwidth=100, reliability=3,
                ownership="B")
            for result in results:
                for path in result["paths"]:
                    # delay = 50 checks
                    self.assertNotIn("S1:1", path)
                    self.assertNotIn("S2:1", path)
                    self.assertNotIn("S3:1", path)
                    self.assertNotIn("S5:1", path)
                    self.assertNotIn("S4:2", path)
                    self.assertNotIn("User1:2", path)
                    self.assertNotIn("S5:5", path)
                    self.assertNotIn("S8:2", path)
                    self.assertNotIn("S5:6", path)
                    self.assertNotIn("User1:3", path)
                    self.assertNotIn("S6:3", path)
                    self.assertNotIn("S9:1", path)
                    self.assertNotIn("S6:4", path)
                    self.assertNotIn("S9:2", path)
                    self.assertNotIn("S6:5", path)
                    self.assertNotIn("S10:1", path)
                    self.assertNotIn("S8:5", path)
                    self.assertNotIn("S9:4", path)
                    self.assertNotIn("User1:4", path)
                    self.assertNotIn("User4:3", path)

                    # bandwidth = 100 checks

                    self.assertNotIn("S3:1", path)
                    self.assertNotIn("S5:1", path)
                    self.assertNotIn("User1:4", path)
                    self.assertNotIn("User4:3", path)

                    # reliability = 3 checks

                    self.assertNotIn("S4:1", path)
                    self.assertNotIn("S5:2", path)
                    self.assertNotIn("S5:3", path)
                    self.assertNotIn("S6:1", path)

                    # ownership = "B" checks

                    self.assertNotIn("S4:1", path)
                    self.assertNotIn("S5:2", path)
                    self.assertNotIn("S4:2", path)
                    self.assertNotIn("User1:2", path)
                    self.assertNotIn("S5:4", path)
                    self.assertNotIn("S6:2", path)
                    self.assertNotIn("S6:5", path)
                    self.assertNotIn("S10:1", path)
                    self.assertNotIn("S8:6", path)
                    self.assertNotIn("S10:2", path)
                    self.assertNotIn("S10:3", path)
                    self.assertNotIn("User2:1", path)

    def test_path8(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability contraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled"""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained(
                point_a, point_b, 4, delay=50, bandwidth=100, reliability=3,
                ownership="B")
            for result in results:
                # delay = 50 checks
                if "delay" in result["metrics"]:

                    for path in result["paths"]:
                        self.assertNotIn("S1:1", path)
                        self.assertNotIn("S2:1", path)
                        self.assertNotIn("S3:1", path)
                        self.assertNotIn("S5:1", path)
                        self.assertNotIn("S4:2", path)
                        self.assertNotIn("User1:2", path)
                        self.assertNotIn("S5:5", path)
                        self.assertNotIn("S8:2", path)
                        self.assertNotIn("S5:6", path)
                        self.assertNotIn("User1:3", path)
                        self.assertNotIn("S6:3", path)
                        self.assertNotIn("S9:1", path)
                        self.assertNotIn("S6:4", path)
                        self.assertNotIn("S9:2", path)
                        self.assertNotIn("S6:5", path)
                        self.assertNotIn("S10:1", path)
                        self.assertNotIn("S8:5", path)
                        self.assertNotIn("S9:4", path)
                        self.assertNotIn("User1:4", path)
                        self.assertNotIn("User4:3", path)

                # bandwidth = 100 checks
                if "bandwidth" in result["metrics"]:
                    for path in result["paths"]:
                        self.assertNotIn("S3:1", path)
                        self.assertNotIn("S5:1", path)
                        self.assertNotIn("User1:4", path)
                        self.assertNotIn("User4:3", path)

                # reliability = 3 checks
                if "reliability" in result["metrics"]:
                    for path in result["paths"]:
                        self.assertNotIn("S4:1", path)
                        self.assertNotIn("S5:2", path)
                        self.assertNotIn("S5:3", path)
                        self.assertNotIn("S6:1", path)

                # ownership = "B" checks
                if "ownership" in result["metrics"]:
                    for path in result["paths"]:
                        self.assertNotIn("S4:1", path)
                        self.assertNotIn("S5:2", path)
                        self.assertNotIn("S4:2", path)
                        self.assertNotIn("User1:2", path)
                        self.assertNotIn("S5:4", path)
                        self.assertNotIn("S6:2", path)
                        self.assertNotIn("S6:5", path)
                        self.assertNotIn("S10:1", path)
                        self.assertNotIn("S8:6", path)
                        self.assertNotIn("S10:2", path)
                        self.assertNotIn("S10:3", path)
                        self.assertNotIn("User2:1", path)

    def test_path9(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability contraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with all but ownership flexible"""
        self.setup()
        combos = combinations(["User1", "User2", "User3", "User4"], 2)
        for point_a, point_b in combos:
            results = self.get_path_constrained2(point_a, point_b,
                                                 {"ownership": "B"}, {
                                                     "delay": 50,
                                                     "bandwidth": 100,
                                                     "reliability": 3})
            for result in results:
                # delay = 50 checks
                if "delay" in result["metrics"]:

                    for path in result["paths"]:
                        self.assertNotIn("S1:1", path)
                        self.assertNotIn("S2:1", path)
                        self.assertNotIn("S3:1", path)
                        self.assertNotIn("S5:1", path)
                        self.assertNotIn("S4:2", path)
                        self.assertNotIn("User1:2", path)
                        self.assertNotIn("S5:5", path)
                        self.assertNotIn("S8:2", path)
                        self.assertNotIn("S5:6", path)
                        self.assertNotIn("User1:3", path)
                        self.assertNotIn("S6:3", path)
                        self.assertNotIn("S9:1", path)
                        self.assertNotIn("S6:4", path)
                        self.assertNotIn("S9:2", path)
                        self.assertNotIn("S6:5", path)
                        self.assertNotIn("S10:1", path)
                        self.assertNotIn("S8:5", path)
                        self.assertNotIn("S9:4", path)
                        self.assertNotIn("User1:4", path)
                        self.assertNotIn("User4:3", path)

                # bandwidth = 100 checks
                if "bandwidth" in result["metrics"]:
                    for path in result["paths"]:
                        self.assertNotIn("S3:1", path)
                        self.assertNotIn("S5:1", path)
                        self.assertNotIn("User1:4", path)
                        self.assertNotIn("User4:3", path)

                # reliability = 3 checks
                if "reliability" in result["metrics"]:
                    for path in result["paths"]:
                        self.assertNotIn("S4:1", path)
                        self.assertNotIn("S5:2", path)
                        self.assertNotIn("S5:3", path)
                        self.assertNotIn("S6:1", path)

                # ownership = "B" checks
                self.assertIn("ownership", result["metrics"])
                for path in result["paths"]:
                    self.assertNotIn("S4:1", path)
                    self.assertNotIn("S5:2", path)
                    self.assertNotIn("S4:2", path)
                    self.assertNotIn("User1:2", path)
                    self.assertNotIn("S5:4", path)
                    self.assertNotIn("S6:2", path)
                    self.assertNotIn("S6:5", path)
                    self.assertNotIn("S10:1", path)
                    self.assertNotIn("S8:6", path)
                    self.assertNotIn("S10:2", path)
                    self.assertNotIn("S10:3", path)
                    self.assertNotIn("User2:1", path)

    def test_path10(self):
        """Tests that TypeError is generated by get_path_constrained

        Tests with ownership using an int type rather than string"""
        self.setup()
        with self.assertRaises(TypeError):
            self.get_path_constrained2(
                "User1", "User2", {"ownership": 1}, None)

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

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

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

        TestSearchResults.create_switch("S3", switches)
        TestSearchResults.add_interfaces(6, switches["S3"], interfaces)

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

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

        TestSearchResults.create_switch("S6", switches)
        TestSearchResults.add_interfaces(5, switches["S6"], interfaces)

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

        TestSearchResults.create_switch("S8", switches)
        TestSearchResults.add_interfaces(8, switches["S8"], interfaces)

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

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

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

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

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

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

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

        links["S1:1<->S2:1"] = Link(interfaces["S1:1"], interfaces["S2:1"])
        links["S1:1<->S2:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 105})

        links["S1:2<->User1:1"] = Link(interfaces["S1:2"],
                                       interfaces["User1:1"])
        links["S1:2<->User1:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S2:2<->User4:1"] = Link(interfaces["S2:2"],
                                       interfaces["User4:1"])
        links["S2:2<->User4:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 10})

        links["S3:1<->S5:1"] = Link(interfaces["S3:1"], interfaces["S5:1"])
        links["S3:1<->S5:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 10, "delay": 112})

        links["S3:2<->S7:1"] = Link(interfaces["S3:2"], interfaces["S7:1"])
        links["S3:2<->S7:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S3:3<->S8:1"] = Link(interfaces["S3:3"], interfaces["S8:1"])
        links["S3:3<->S8:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S3:4<->S11:1"] = Link(interfaces["S3:4"], interfaces["S11:1"])
        links["S3:4<->S11:1"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 6})

        links["S3:5<->User3:1"] = Link(interfaces["S3:5"],
                                       interfaces["User3:1"])
        links["S3:5<->User3:1"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S3:6<->User4:2"] = Link(interfaces["S3:6"],
                                       interfaces["User4:2"])
        links["S3:6<->User4:2"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 10})

        links["S4:1<->S5:2"] = Link(interfaces["S4:1"], interfaces["S5:2"])
        links["S4:1<->S5:2"].extend_metadata(
            {"reliability": 1, "bandwidth": 100, "delay": 30,
             "ownership": "A"})

        links["S4:2<->User1:2"] = Link(interfaces["S4:2"],
                                       interfaces["User1:2"])
        links["S4:2<->User1:2"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 110,
             "ownership": "A"})

        links["S5:3<->S6:1"] = Link(interfaces["S5:3"], interfaces["S6:1"])
        links["S5:3<->S6:1"].extend_metadata(
            {"reliability": 1, "bandwidth": 100, "delay": 40})

        links["S5:4<->S6:2"] = Link(interfaces["S5:4"], interfaces["S6:2"])
        links["S5:4<->S6:2"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 40,
             "ownership": "A"})

        links["S5:5<->S8:2"] = Link(interfaces["S5:5"], interfaces["S8:2"])
        links["S5:5<->S8:2"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 112})

        links["S5:6<->User1:3"] = Link(interfaces["S5:6"],
                                       interfaces["User1:3"])
        links["S5:6<->User1:3"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 60})

        links["S6:3<->S9:1"] = Link(interfaces["S6:3"], interfaces["S9:1"])
        links["S6:3<->S9:1"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 60})

        links["S6:4<->S9:2"] = Link(interfaces["S6:4"], interfaces["S9:2"])
        links["S6:4<->S9:2"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 62})

        links["S6:5<->S10:1"] = Link(interfaces["S6:5"], interfaces["S10:1"])
        links["S6:5<->S10:1"].extend_metadata(
            {"bandwidth": 100, "delay": 108, "ownership": "A"})

        links["S7:2<->S8:3"] = Link(interfaces["S7:2"], interfaces["S8:3"])
        links["S7:2<->S8:3"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S8:4<->S9:3"] = Link(interfaces["S8:4"], interfaces["S9:3"])
        links["S8:4<->S9:3"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 32})

        links["S8:5<->S9:4"] = Link(interfaces["S8:5"], interfaces["S9:4"])
        links["S8:5<->S9:4"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 110})

        links["S8:6<->S10:2"] = Link(interfaces["S8:6"], interfaces["S10:2"])
        links["S8:6<->S10:2"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "ownership": "A"})

        links["S8:7<->S11:2"] = Link(interfaces["S8:7"], interfaces["S11:2"])
        links["S8:7<->S11:2"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 7})

        links["S8:8<->User3:2"] = Link(interfaces["S8:8"],
                                       interfaces["User3:2"])
        links["S8:8<->User3:2"].extend_metadata(
            {"reliability": 5, "bandwidth": 100, "delay": 1})

        links["S10:3<->User2:1"] = Link(interfaces["S10:3"],
                                        interfaces["User2:1"])
        links["S10:3<->User2:1"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 10,
             "ownership": "A"})

        links["S11:3<->User2:2"] = Link(interfaces["S11:3"],
                                        interfaces["User2:2"])
        links["S11:3<->User2:2"].extend_metadata(
            {"reliability": 3, "bandwidth": 100, "delay": 6})

        links["User1:4<->User4:3"] = Link(interfaces["User1:4"],
                                          interfaces["User4:3"])
        links["User1:4<->User4:3"].extend_metadata(
            {"reliability": 5, "bandwidth": 10, "delay": 105})

        return (switches, links)


1		"""Module to test the KytosGraph in graph.py."""
2		from itertools import combinations
3
4		# Core modules to import
5		from kytos.core.link import Link
6
7		# module under test
8		from tests.unit.test_search_results import TestSearchResults
9
10
11		class TestSearchResults2(TestSearchResults):
12		"""Tests for the graph class."""
13
14		def test_path1(self):
15		"""Tests paths between all users using unconstrained path alogrithm."""
16		self.setup()
17		combos = combinations(["User1", "User2", "User3", "User4"], 2)
18		for point_a, point_b in combos:
19		results = self.get_path(point_a, point_b)
20		self.assertNotEqual(results, [])
21
22		def test_path2(self):
23		"""Tests paths between all users using constrained path algorithm,
24		with no constraints set."""
25		self.setup()
26		combos = combinations(["User1", "User2", "User3", "User4"], 2)
27		for point_a, point_b in combos:
28		results = self.get_path_constrained(point_a, point_b)
29		self.assertNotEqual(results, [])
30
31		def test_path3(self):
32		"""Tests paths between all users using constrained path algorithm,
33		with the ownership constraint set to B."""
34		self.setup()
35		combos = combinations(["User1", "User2", "User3", "User4"], 2)
36		for point_a, point_b in combos:
37		results = self.get_path_constrained(
38		point_a, point_b, 0, ownership="B")
39		for result in results:
40		for path in result["paths"]:
41		self.assertNotIn("S4:1", path)
42		self.assertNotIn("S5:2", path)
43		self.assertNotIn("S4:2", path)
44		self.assertNotIn("User1:2", path)
45		self.assertNotIn("S5:4", path)
46		self.assertNotIn("S6:2", path)
47		self.assertNotIn("S6:5", path)
48		self.assertNotIn("S10:1", path)
49		self.assertNotIn("S8:6", path)
50		self.assertNotIn("S10:2", path)
51		self.assertNotIn("S10:3", path)
52		self.assertNotIn("User2:1", path)
53
54		def test_path4(self):
55		"""Tests paths between all users using constrained path algorithm,
56		with the reliability constraint set to 3."""
57		self.setup()
58		combos = combinations(["User1", "User2", "User3", "User4"], 2)
59		for point_a, point_b in combos:
60		results = self.get_path_constrained(
61		point_a, point_b, 0, reliability=3)
62		for result in results:
63		for path in result["paths"]:
64		self.assertNotIn("S4:1", path)
65		self.assertNotIn("S5:2", path)
66		self.assertNotIn("S5:3", path)
67		self.assertNotIn("S6:1", path)
68
69		def test_path5(self):
70		"""Tests paths between all users using constrained path algorithm,
71		with the bandwidth contraint set to 100."""
72		self.setup()
73		combos = combinations(["User1", "User2", "User3", "User4"], 2)
74		for point_a, point_b in combos:
75		results = self.get_path_constrained(
76		point_a, point_b, 0, bandwidth=100)
77		for result in results:
78		for path in result["paths"]:
79		self.assertNotIn("S3:1", path)
80		self.assertNotIn("S5:1", path)
81		self.assertNotIn("User1:4", path)
82		self.assertNotIn("User4:3", path)
83
84		def test_path6(self):
85		"""Tests paths between all users using constrained path algorithm,
86		with the delay constraint set to 50."""
87		self.setup()
88		combos = combinations(["User1", "User2", "User3", "User4"], 2)
89		for point_a, point_b in combos:
90		results = self.get_path_constrained(point_a, point_b, 0, delay=50)
91		for result in results:
92		for path in result["paths"]:
93		self.assertNotIn("S1:1", path)
94		self.assertNotIn("S2:1", path)
95		self.assertNotIn("S3:1", path)
96		self.assertNotIn("S5:1", path)
97		self.assertNotIn("S4:2", path)
98		self.assertNotIn("User1:2", path)
99		self.assertNotIn("S5:5", path)
100		self.assertNotIn("S8:2", path)
101		self.assertNotIn("S5:6", path)
102		self.assertNotIn("User1:3", path)
103		self.assertNotIn("S6:3", path)
104		self.assertNotIn("S9:1", path)
105		self.assertNotIn("S6:4", path)
106		self.assertNotIn("S9:2", path)
107		self.assertNotIn("S6:5", path)
108		self.assertNotIn("S10:1", path)
109		self.assertNotIn("S8:5", path)
110		self.assertNotIn("S9:4", path)
111		self.assertNotIn("User1:4", path)
112		self.assertNotIn("User4:3", path)
113
114		def test_path7(self):
115		"""Tests paths between all users using constrained path algorithm,
116		with the delay constraint set to 50, the bandwidth constraint set
117		to 100, the reliability contraint set to 3, and the ownership
118		constraint set to 'B' """
119		self.setup()
120		combos = combinations(["User1", "User2", "User3", "User4"], 2)
121		for point_a, point_b in combos:
122		results = self.get_path_constrained(
123		point_a, point_b, 0, delay=50, bandwidth=100, reliability=3,
124		ownership="B")
125		for result in results:
126		for path in result["paths"]:
127		# delay = 50 checks
128		self.assertNotIn("S1:1", path)
129		self.assertNotIn("S2:1", path)
130		self.assertNotIn("S3:1", path)
131		self.assertNotIn("S5:1", path)
132		self.assertNotIn("S4:2", path)
133		self.assertNotIn("User1:2", path)
134		self.assertNotIn("S5:5", path)
135		self.assertNotIn("S8:2", path)
136		self.assertNotIn("S5:6", path)
137		self.assertNotIn("User1:3", path)
138		self.assertNotIn("S6:3", path)
139		self.assertNotIn("S9:1", path)
140		self.assertNotIn("S6:4", path)
141		self.assertNotIn("S9:2", path)
142		self.assertNotIn("S6:5", path)
143		self.assertNotIn("S10:1", path)
144		self.assertNotIn("S8:5", path)
145		self.assertNotIn("S9:4", path)
146		self.assertNotIn("User1:4", path)
147		self.assertNotIn("User4:3", path)
148
149		# bandwidth = 100 checks
150
151		self.assertNotIn("S3:1", path)
152		self.assertNotIn("S5:1", path)
153		self.assertNotIn("User1:4", path)
154		self.assertNotIn("User4:3", path)
155
156		# reliability = 3 checks
157
158		self.assertNotIn("S4:1", path)
159		self.assertNotIn("S5:2", path)
160		self.assertNotIn("S5:3", path)
161		self.assertNotIn("S6:1", path)
162
163		# ownership = "B" checks
164
165		self.assertNotIn("S4:1", path)
166		self.assertNotIn("S5:2", path)
167		self.assertNotIn("S4:2", path)
168		self.assertNotIn("User1:2", path)
169		self.assertNotIn("S5:4", path)
170		self.assertNotIn("S6:2", path)
171		self.assertNotIn("S6:5", path)
172		self.assertNotIn("S10:1", path)
173		self.assertNotIn("S8:6", path)
174		self.assertNotIn("S10:2", path)
175		self.assertNotIn("S10:3", path)
176		self.assertNotIn("User2:1", path)
177
178		def test_path8(self):
179		"""Tests paths between all users using constrained path algorithm,
180		with the delay constraint set to 50, the bandwidth constraint
181		set to 100, the reliability contraint set to 3, and the ownership
182		constraint set to 'B'
183
184		Tests conducted with flexibility enabled"""
185		self.setup()
186		combos = combinations(["User1", "User2", "User3", "User4"], 2)
187		for point_a, point_b in combos:
188		results = self.get_path_constrained(
189		point_a, point_b, 4, delay=50, bandwidth=100, reliability=3,
190		ownership="B")
191		for result in results:
192		# delay = 50 checks
193	View Code Duplication	if "delay" in result["metrics"]:
		0 ignored issues – show Duplication introduced 2020-05-28 14:34 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
194		for path in result["paths"]:
195		self.assertNotIn("S1:1", path)
196		self.assertNotIn("S2:1", path)
197		self.assertNotIn("S3:1", path)
198		self.assertNotIn("S5:1", path)
199		self.assertNotIn("S4:2", path)
200		self.assertNotIn("User1:2", path)
201		self.assertNotIn("S5:5", path)
202		self.assertNotIn("S8:2", path)
203		self.assertNotIn("S5:6", path)
204		self.assertNotIn("User1:3", path)
205		self.assertNotIn("S6:3", path)
206		self.assertNotIn("S9:1", path)
207		self.assertNotIn("S6:4", path)
208		self.assertNotIn("S9:2", path)
209		self.assertNotIn("S6:5", path)
210		self.assertNotIn("S10:1", path)
211		self.assertNotIn("S8:5", path)
212		self.assertNotIn("S9:4", path)
213		self.assertNotIn("User1:4", path)
214		self.assertNotIn("User4:3", path)
215
216		# bandwidth = 100 checks
217		if "bandwidth" in result["metrics"]:
218		for path in result["paths"]:
219		self.assertNotIn("S3:1", path)
220		self.assertNotIn("S5:1", path)
221		self.assertNotIn("User1:4", path)
222		self.assertNotIn("User4:3", path)
223
224		# reliability = 3 checks
225		if "reliability" in result["metrics"]:
226		for path in result["paths"]:
227		self.assertNotIn("S4:1", path)
228		self.assertNotIn("S5:2", path)
229		self.assertNotIn("S5:3", path)
230		self.assertNotIn("S6:1", path)
231
232		# ownership = "B" checks
233		if "ownership" in result["metrics"]:
234		for path in result["paths"]:
235		self.assertNotIn("S4:1", path)
236		self.assertNotIn("S5:2", path)
237		self.assertNotIn("S4:2", path)
238		self.assertNotIn("User1:2", path)
239		self.assertNotIn("S5:4", path)
240		self.assertNotIn("S6:2", path)
241		self.assertNotIn("S6:5", path)
242		self.assertNotIn("S10:1", path)
243		self.assertNotIn("S8:6", path)
244		self.assertNotIn("S10:2", path)
245		self.assertNotIn("S10:3", path)
246		self.assertNotIn("User2:1", path)
247
248		def test_path9(self):
249		"""Tests paths between all users using constrained path algorithm,
250		with the delay constraint set to 50, the bandwidth constraint
251		set to 100, the reliability contraint set to 3, and the ownership
252		constraint set to 'B'
253
254		Tests conducted with all but ownership flexible"""
255		self.setup()
256		combos = combinations(["User1", "User2", "User3", "User4"], 2)
257		for point_a, point_b in combos:
258		results = self.get_path_constrained2(point_a, point_b,
259		{"ownership": "B"}, {
260		"delay": 50,
261		"bandwidth": 100,
262		"reliability": 3})
263		for result in results:
264		# delay = 50 checks
265	View Code Duplication	if "delay" in result["metrics"]:
		0 ignored issues – show Duplication introduced 2020-05-28 14:34 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
266		for path in result["paths"]:
267		self.assertNotIn("S1:1", path)
268		self.assertNotIn("S2:1", path)
269		self.assertNotIn("S3:1", path)
270		self.assertNotIn("S5:1", path)
271		self.assertNotIn("S4:2", path)
272		self.assertNotIn("User1:2", path)
273		self.assertNotIn("S5:5", path)
274		self.assertNotIn("S8:2", path)
275		self.assertNotIn("S5:6", path)
276		self.assertNotIn("User1:3", path)
277		self.assertNotIn("S6:3", path)
278		self.assertNotIn("S9:1", path)
279		self.assertNotIn("S6:4", path)
280		self.assertNotIn("S9:2", path)
281		self.assertNotIn("S6:5", path)
282		self.assertNotIn("S10:1", path)
283		self.assertNotIn("S8:5", path)
284		self.assertNotIn("S9:4", path)
285		self.assertNotIn("User1:4", path)
286		self.assertNotIn("User4:3", path)
287
288		# bandwidth = 100 checks
289		if "bandwidth" in result["metrics"]:
290		for path in result["paths"]:
291		self.assertNotIn("S3:1", path)
292		self.assertNotIn("S5:1", path)
293		self.assertNotIn("User1:4", path)
294		self.assertNotIn("User4:3", path)
295
296		# reliability = 3 checks
297		if "reliability" in result["metrics"]:
298		for path in result["paths"]:
299		self.assertNotIn("S4:1", path)
300		self.assertNotIn("S5:2", path)
301		self.assertNotIn("S5:3", path)
302		self.assertNotIn("S6:1", path)
303
304		# ownership = "B" checks
305		self.assertIn("ownership", result["metrics"])
306		for path in result["paths"]:
307		self.assertNotIn("S4:1", path)
308		self.assertNotIn("S5:2", path)
309		self.assertNotIn("S4:2", path)
310		self.assertNotIn("User1:2", path)
311		self.assertNotIn("S5:4", path)
312		self.assertNotIn("S6:2", path)
313		self.assertNotIn("S6:5", path)
314		self.assertNotIn("S10:1", path)
315		self.assertNotIn("S8:6", path)
316		self.assertNotIn("S10:2", path)
317		self.assertNotIn("S10:3", path)
318		self.assertNotIn("User2:1", path)
319
320		def test_path10(self):
321		"""Tests that TypeError is generated by get_path_constrained
322
323		Tests with ownership using an int type rather than string"""
324		self.setup()
325		with self.assertRaises(TypeError):
326		self.get_path_constrained2(
327		"User1", "User2", {"ownership": 1}, None)
328
329		@staticmethod
330		def generate_topology():
331		"""Generates a predetermined topology"""
332		switches = {}
333		interfaces = {}
334		links = {}
335
336		TestSearchResults.create_switch("S1", switches)
337		TestSearchResults.add_interfaces(2, switches["S1"], interfaces)
338
339		TestSearchResults.create_switch("S2", switches)
340		TestSearchResults.add_interfaces(2, switches["S2"], interfaces)
341
342		TestSearchResults.create_switch("S3", switches)
343		TestSearchResults.add_interfaces(6, switches["S3"], interfaces)
344
345		TestSearchResults.create_switch("S4", switches)
346		TestSearchResults.add_interfaces(2, switches["S4"], interfaces)
347
348		TestSearchResults.create_switch("S5", switches)
349		TestSearchResults.add_interfaces(6, switches["S5"], interfaces)
350
351		TestSearchResults.create_switch("S6", switches)
352		TestSearchResults.add_interfaces(5, switches["S6"], interfaces)
353
354		TestSearchResults.create_switch("S7", switches)
355		TestSearchResults.add_interfaces(2, switches["S7"], interfaces)
356
357		TestSearchResults.create_switch("S8", switches)
358		TestSearchResults.add_interfaces(8, switches["S8"], interfaces)
359
360		TestSearchResults.create_switch("S9", switches)
361		TestSearchResults.add_interfaces(4, switches["S9"], interfaces)
362
363		TestSearchResults.create_switch("S10", switches)
364		TestSearchResults.add_interfaces(3, switches["S10"], interfaces)
365
366		TestSearchResults.create_switch("S11", switches)
367		TestSearchResults.add_interfaces(3, switches["S11"], interfaces)
368
369		TestSearchResults.create_switch("User1", switches)
370		TestSearchResults.add_interfaces(4, switches["User1"], interfaces)
371
372		TestSearchResults.create_switch("User2", switches)
373		TestSearchResults.add_interfaces(2, switches["User2"], interfaces)
374
375		TestSearchResults.create_switch("User3", switches)
376		TestSearchResults.add_interfaces(2, switches["User3"], interfaces)
377
378		TestSearchResults.create_switch("User4", switches)
379		TestSearchResults.add_interfaces(3, switches["User4"], interfaces)
380
381		links["S1:1<->S2:1"] = Link(interfaces["S1:1"], interfaces["S2:1"])
382		links["S1:1<->S2:1"].extend_metadata(
383		{"reliability": 5, "bandwidth": 100, "delay": 105})
384
385		links["S1:2<->User1:1"] = Link(interfaces["S1:2"],
386		interfaces["User1:1"])
387		links["S1:2<->User1:1"].extend_metadata(
388		{"reliability": 5, "bandwidth": 100, "delay": 1})
389
390		links["S2:2<->User4:1"] = Link(interfaces["S2:2"],
391		interfaces["User4:1"])
392		links["S2:2<->User4:1"].extend_metadata(
393		{"reliability": 5, "bandwidth": 100, "delay": 10})
394
395		links["S3:1<->S5:1"] = Link(interfaces["S3:1"], interfaces["S5:1"])
396		links["S3:1<->S5:1"].extend_metadata(
397		{"reliability": 5, "bandwidth": 10, "delay": 112})
398
399		links["S3:2<->S7:1"] = Link(interfaces["S3:2"], interfaces["S7:1"])
400		links["S3:2<->S7:1"].extend_metadata(
401		{"reliability": 5, "bandwidth": 100, "delay": 1})
402
403		links["S3:3<->S8:1"] = Link(interfaces["S3:3"], interfaces["S8:1"])
404		links["S3:3<->S8:1"].extend_metadata(
405		{"reliability": 5, "bandwidth": 100, "delay": 1})
406
407		links["S3:4<->S11:1"] = Link(interfaces["S3:4"], interfaces["S11:1"])
408		links["S3:4<->S11:1"].extend_metadata(
409		{"reliability": 3, "bandwidth": 100, "delay": 6})
410
411		links["S3:5<->User3:1"] = Link(interfaces["S3:5"],
412		interfaces["User3:1"])
413		links["S3:5<->User3:1"].extend_metadata(
414		{"reliability": 5, "bandwidth": 100, "delay": 1})
415
416		links["S3:6<->User4:2"] = Link(interfaces["S3:6"],
417		interfaces["User4:2"])
418		links["S3:6<->User4:2"].extend_metadata(
419		{"reliability": 5, "bandwidth": 100, "delay": 10})
420
421		links["S4:1<->S5:2"] = Link(interfaces["S4:1"], interfaces["S5:2"])
422		links["S4:1<->S5:2"].extend_metadata(
423		{"reliability": 1, "bandwidth": 100, "delay": 30,
424		"ownership": "A"})
425
426		links["S4:2<->User1:2"] = Link(interfaces["S4:2"],
427		interfaces["User1:2"])
428		links["S4:2<->User1:2"].extend_metadata(
429		{"reliability": 3, "bandwidth": 100, "delay": 110,
430		"ownership": "A"})
431
432		links["S5:3<->S6:1"] = Link(interfaces["S5:3"], interfaces["S6:1"])
433		links["S5:3<->S6:1"].extend_metadata(
434		{"reliability": 1, "bandwidth": 100, "delay": 40})
435
436		links["S5:4<->S6:2"] = Link(interfaces["S5:4"], interfaces["S6:2"])
437		links["S5:4<->S6:2"].extend_metadata(
438		{"reliability": 3, "bandwidth": 100, "delay": 40,
439		"ownership": "A"})
440
441		links["S5:5<->S8:2"] = Link(interfaces["S5:5"], interfaces["S8:2"])
442		links["S5:5<->S8:2"].extend_metadata(
443		{"reliability": 5, "bandwidth": 100, "delay": 112})
444
445		links["S5:6<->User1:3"] = Link(interfaces["S5:6"],
446		interfaces["User1:3"])
447		links["S5:6<->User1:3"].extend_metadata(
448		{"reliability": 3, "bandwidth": 100, "delay": 60})
449
450		links["S6:3<->S9:1"] = Link(interfaces["S6:3"], interfaces["S9:1"])
451		links["S6:3<->S9:1"].extend_metadata(
452		{"reliability": 3, "bandwidth": 100, "delay": 60})
453
454		links["S6:4<->S9:2"] = Link(interfaces["S6:4"], interfaces["S9:2"])
455		links["S6:4<->S9:2"].extend_metadata(
456		{"reliability": 5, "bandwidth": 100, "delay": 62})
457
458		links["S6:5<->S10:1"] = Link(interfaces["S6:5"], interfaces["S10:1"])
459		links["S6:5<->S10:1"].extend_metadata(
460		{"bandwidth": 100, "delay": 108, "ownership": "A"})
461
462		links["S7:2<->S8:3"] = Link(interfaces["S7:2"], interfaces["S8:3"])
463		links["S7:2<->S8:3"].extend_metadata(
464		{"reliability": 5, "bandwidth": 100, "delay": 1})
465
466		links["S8:4<->S9:3"] = Link(interfaces["S8:4"], interfaces["S9:3"])
467		links["S8:4<->S9:3"].extend_metadata(
468		{"reliability": 3, "bandwidth": 100, "delay": 32})
469
470		links["S8:5<->S9:4"] = Link(interfaces["S8:5"], interfaces["S9:4"])
471		links["S8:5<->S9:4"].extend_metadata(
472		{"reliability": 3, "bandwidth": 100, "delay": 110})
473
474		links["S8:6<->S10:2"] = Link(interfaces["S8:6"], interfaces["S10:2"])
475		links["S8:6<->S10:2"].extend_metadata(
476		{"reliability": 5, "bandwidth": 100, "ownership": "A"})
477
478		links["S8:7<->S11:2"] = Link(interfaces["S8:7"], interfaces["S11:2"])
479		links["S8:7<->S11:2"].extend_metadata(
480		{"reliability": 3, "bandwidth": 100, "delay": 7})
481
482		links["S8:8<->User3:2"] = Link(interfaces["S8:8"],
483		interfaces["User3:2"])
484		links["S8:8<->User3:2"].extend_metadata(
485		{"reliability": 5, "bandwidth": 100, "delay": 1})
486
487		links["S10:3<->User2:1"] = Link(interfaces["S10:3"],
488		interfaces["User2:1"])
489		links["S10:3<->User2:1"].extend_metadata(
490		{"reliability": 3, "bandwidth": 100, "delay": 10,
491		"ownership": "A"})
492
493		links["S11:3<->User2:2"] = Link(interfaces["S11:3"],
494		interfaces["User2:2"])
495		links["S11:3<->User2:2"].extend_metadata(
496		{"reliability": 3, "bandwidth": 100, "delay": 6})
497
498		links["User1:4<->User4:3"] = Link(interfaces["User1:4"],
499		interfaces["User4:3"])
500		links["User1:4<->User4:3"].extend_metadata(
501		{"reliability": 5, "bandwidth": 10, "delay": 105})
502
503		return (switches, links)
504

kytos / pathfinder

Pull Request — master (#58)

TestSearchResults2.generate_topology() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like