build.tests.unit.test_main.TestMain.test_load_flows() - Code Metrics - Inspection of "Add flow persistence (#90)" - kytos/flow_manager - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5bb45b...07a00f )

by Humberto

created 2020-12-23 16:32 UTC

TestMain.test_load_flows() A

↳ Parent: build.tests.unit.test_main

Complexity

Conditions

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nop	2
dl	0
loc	5
rs	10
c	0
b	0
f	0

"""Test Main methods."""
from unittest import TestCase
from unittest.mock import MagicMock, patch

from kytos.lib.helpers import (get_controller_mock, get_kytos_event_mock,
                               get_switch_mock, get_test_client)


# pylint: disable=protected-access
class TestMain(TestCase):
    """Tests for the Main class."""

    API_URL = 'http://localhost:8181/api/kytos/flow_manager'

    def setUp(self):
        patch('kytos.core.helpers.run_on_thread', lambda x: x).start()
        # pylint: disable=import-outside-toplevel
        from napps.kytos.flow_manager.main import Main

        self.addCleanup(patch.stopall)

        controller = get_controller_mock()
        self.switch_01 = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
        self.switch_01.is_enabled.return_value = True
        self.switch_01.flows = []

        self.switch_02 = get_switch_mock("00:00:00:00:00:00:00:02", 0x04)
        self.switch_02.is_enabled.return_value = False
        self.switch_02.flows = []

        controller.switches = {"00:00:00:00:00:00:00:01": self.switch_01,
                               "00:00:00:00:00:00:00:02": self.switch_02}

        self.napp = Main(controller)

    def test_rest_list_without_dpid(self):
        """Test list rest method withoud dpid."""
        flow_1 = MagicMock()
        flow_1.as_dict.return_value = {'flow_1': 'data'}
        flow_2 = MagicMock()
        flow_2.as_dict.return_value = {'flow_2': 'data'}
        self.switch_01.flows.append(flow_1)
        self.switch_02.flows.append(flow_2)

        api = get_test_client(self.napp.controller, self.napp)
        url = f'{self.API_URL}/v2/flows'

        response = api.get(url)
        expected = {'00:00:00:00:00:00:00:01': {'flows': [{'flow_1': 'data'}]},
                    '00:00:00:00:00:00:00:02': {'flows': [{'flow_2': 'data'}]}}

        self.assertEqual(response.json, expected)
        self.assertEqual(response.status_code, 200)

    def test_rest_list_with_dpid(self):
        """Test list rest method with dpid."""
        flow_1 = MagicMock()
        flow_1.as_dict.return_value = {'flow_1': 'data'}
        self.switch_01.flows.append(flow_1)

        api = get_test_client(self.napp.controller, self.napp)
        url = f'{self.API_URL}/v2/flows/00:00:00:00:00:00:00:01'

        response = api.get(url)
        expected = {'00:00:00:00:00:00:00:01': {'flows': [{'flow_1': 'data'}]}}

        self.assertEqual(response.json, expected)
        self.assertEqual(response.status_code, 200)

    @patch('napps.kytos.flow_manager.main.Main._install_flows')
    def test_rest_add_and_delete_without_dpid(self, mock_install_flows):
        """Test add and delete rest method without dpid."""
        api = get_test_client(self.napp.controller, self.napp)

        for method in ['flows', 'delete']:
            url = f'{self.API_URL}/v2/{method}'

            response_1 = api.post(url, json={'data': '123'})
            response_2 = api.post(url)

            self.assertEqual(response_1.status_code, 200)
            self.assertEqual(response_2.status_code, 404)

        self.assertEqual(mock_install_flows.call_count, 2)

    @patch('napps.kytos.flow_manager.main.Main._install_flows')
    def test_rest_add_and_delete_with_dpid(self, mock_install_flows):
        """Test add and delete rest method with dpid."""
        api = get_test_client(self.napp.controller, self.napp)

        for method in ['flows', 'delete']:
            url_1 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:01'
            url_2 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:02'
            url_3 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:03'

            response_1 = api.post(url_1)
            response_2 = api.post(url_1, json={'data': '123'})
            response_3 = api.post(url_2, json={'data': '123'})
            response_4 = api.post(url_3, json={'data': '123'})

            self.assertEqual(response_1.status_code, 404)
            self.assertEqual(response_2.status_code, 200)
            if method == 'flows':
                self.assertEqual(response_3.status_code, 404)
            else:
                self.assertEqual(response_3.status_code, 200)
            self.assertEqual(response_4.status_code, 404)

        self.assertEqual(mock_install_flows.call_count, 3)

    def test_get_all_switches_enabled(self):
        """Test _get_all_switches_enabled method."""
        switches = self.napp._get_all_switches_enabled()

        self.assertEqual(switches, [self.switch_01])

    @patch('napps.kytos.flow_manager.main.Main._store_changed_flows')
    @patch('napps.kytos.flow_manager.main.Main._send_napp_event')
    @patch('napps.kytos.flow_manager.main.Main._add_flow_mod_sent')
    @patch('napps.kytos.flow_manager.main.Main._send_flow_mod')
    @patch('napps.kytos.flow_manager.main.FlowFactory.get_class')
    def test_install_flows(self, *args):
        """Test _install_flows method."""
        (mock_flow_factory, mock_send_flow_mod, mock_add_flow_mod_sent,
         mock_send_napp_event, _) = args
        serializer = MagicMock()
        flow = MagicMock()
        flow_mod = MagicMock()

        flow.as_of_add_flow_mod.return_value = flow_mod
        serializer.from_dict.return_value = flow
        mock_flow_factory.return_value = serializer

        flows_dict = {'flows': [MagicMock()]}
        switches = [self.switch_01]
        self.napp._install_flows('add', flows_dict, switches)

        mock_send_flow_mod.assert_called_with(flow.switch, flow_mod)
        mock_add_flow_mod_sent.assert_called_with(flow_mod.header.xid,
                                                  flow, 'add')
        mock_send_napp_event.assert_called_with(self.switch_01, flow, 'add')

    def test_add_flow_mod_sent(self):
        """Test _add_flow_mod_sent method."""
        xid = 0
        flow = MagicMock()

        self.napp._add_flow_mod_sent(xid, flow, 'add')

        self.assertEqual(self.napp._flow_mods_sent[xid], (flow, 'add'))

    @patch('kytos.core.buffers.KytosEventBuffer.put')
    def test_send_flow_mod(self, mock_buffers_put):
        """Test _send_flow_mod method."""
        switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
        flow_mod = MagicMock()

        self.napp._send_flow_mod(switch, flow_mod)

        mock_buffers_put.assert_called()

    @patch('kytos.core.buffers.KytosEventBuffer.put')
    def test_send_napp_event(self, mock_buffers_put):
        """Test _send_napp_event method."""
        switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
        flow = MagicMock()

        for command in ['add', 'delete', 'error']:
            self.napp._send_napp_event(switch, flow, command)

        self.assertEqual(mock_buffers_put.call_count, 3)

    @patch('napps.kytos.flow_manager.main.Main._send_napp_event')
    def test_handle_errors(self, mock_send_napp_event):
        """Test handle_errors method."""
        flow = MagicMock()
        self.napp._flow_mods_sent[0] = (flow, 'add')

        message = MagicMock()
        message.header.xid.value = 0
        message.error_type = 2
        message.code = 5
        event = get_kytos_event_mock(name='.*.of_core.*.ofpt_error',
                                     content={'message': message})
        self.napp.handle_errors(event)

        mock_send_napp_event.assert_called_with(flow.switch, flow, 'error',
                                                error_command='add',
                                                error_code=5, error_type=2)

    @patch("napps.kytos.flow_manager.main.StoreHouse.get_data")
    def test_load_flows(self, mock_storehouse):
        """Test load flows."""
        self.napp._load_flows()
        mock_storehouse.assert_called()

    @patch("napps.kytos.flow_manager.main.Main._install_flows")
    def test_resend_stored_flows(self, mock_install_flows):
        """Test resend stored flows."""
        dpid = "00:00:00:00:00:00:00:01"
        switch = get_switch_mock(dpid, 0x04)
        mock_event = MagicMock()
        flow = {"command": "add", "flow": MagicMock()}

        flows = {"flow_list": [flow]}
        mock_event.content = {"switch": switch}
        self.napp.controller.switches = {dpid: switch}
        self.napp.stored_flows = {dpid: flows}
        self.napp.resend_stored_flows(mock_event)
        mock_install_flows.assert_called()

    @patch("napps.kytos.of_core.flow.FlowFactory.get_class")
    @patch("napps.kytos.flow_manager.main.StoreHouse.save_flow")
    def test_store_changed_flows(self, mock_save_flow, _):
        """Test store changed flows."""
        dpid = "00:00:00:00:00:00:00:01"
        switch = get_switch_mock(dpid, 0x04)
        switch.id = dpid
        flow = {
            "priority": 17,
            "cookie": 84114964,
            "command": "add",
            "match": {"dl_dst": "00:15:af:d5:38:98"},
        }
        match_fields = {
            "priority": 17,
            "cookie": 84114964,
            "command": "add",
            "dl_dst": "00:15:af:d5:38:98",
        }
        flows = {"flow": flow}

        command = "add"
        flow_list = {
            "flow_list": [
                {"match_fields": match_fields, "command": "delete",
                 "flow": flow}
            ]
        }
        self.napp.stored_flows = {dpid: flow_list}
        self.napp._store_changed_flows(command, flows, switch)
        mock_save_flow.assert_called()

        self.napp.stored_flows = {}
        self.napp._store_changed_flows(command, flows, switch)
        mock_save_flow.assert_called()


1			"""Test Main methods."""
2			from unittest import TestCase
3			from unittest.mock import MagicMock, patch
4
5			from kytos.lib.helpers import (get_controller_mock, get_kytos_event_mock,
6			get_switch_mock, get_test_client)
7
8
9			# pylint: disable=protected-access
10			class TestMain(TestCase):
11			"""Tests for the Main class."""
12
13			API_URL = 'http://localhost:8181/api/kytos/flow_manager'
14
15			def setUp(self):
16			patch('kytos.core.helpers.run_on_thread', lambda x: x).start()
17			# pylint: disable=import-outside-toplevel
18			from napps.kytos.flow_manager.main import Main
19
20			self.addCleanup(patch.stopall)
21
22			controller = get_controller_mock()
23			self.switch_01 = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
24			self.switch_01.is_enabled.return_value = True
25			self.switch_01.flows = []
26
27			self.switch_02 = get_switch_mock("00:00:00:00:00:00:00:02", 0x04)
28			self.switch_02.is_enabled.return_value = False
29			self.switch_02.flows = []
30
31			controller.switches = {"00:00:00:00:00:00:00:01": self.switch_01,
32			"00:00:00:00:00:00:00:02": self.switch_02}
33
34			self.napp = Main(controller)
35
36			def test_rest_list_without_dpid(self):
37			"""Test list rest method withoud dpid."""
38			flow_1 = MagicMock()
39			flow_1.as_dict.return_value = {'flow_1': 'data'}
40			flow_2 = MagicMock()
41			flow_2.as_dict.return_value = {'flow_2': 'data'}
42			self.switch_01.flows.append(flow_1)
43			self.switch_02.flows.append(flow_2)
44
45			api = get_test_client(self.napp.controller, self.napp)
46			url = f'{self.API_URL}/v2/flows'
47
48			response = api.get(url)
49			expected = {'00:00:00:00:00:00:00:01': {'flows': [{'flow_1': 'data'}]},
50			'00:00:00:00:00:00:00:02': {'flows': [{'flow_2': 'data'}]}}
51
52			self.assertEqual(response.json, expected)
53			self.assertEqual(response.status_code, 200)
54
55			def test_rest_list_with_dpid(self):
56			"""Test list rest method with dpid."""
57			flow_1 = MagicMock()
58			flow_1.as_dict.return_value = {'flow_1': 'data'}
59			self.switch_01.flows.append(flow_1)
60
61			api = get_test_client(self.napp.controller, self.napp)
62			url = f'{self.API_URL}/v2/flows/00:00:00:00:00:00:00:01'
63
64			response = api.get(url)
65			expected = {'00:00:00:00:00:00:00:01': {'flows': [{'flow_1': 'data'}]}}
66
67			self.assertEqual(response.json, expected)
68			self.assertEqual(response.status_code, 200)
69
70			@patch('napps.kytos.flow_manager.main.Main._install_flows')
71			def test_rest_add_and_delete_without_dpid(self, mock_install_flows):
72			"""Test add and delete rest method without dpid."""
73			api = get_test_client(self.napp.controller, self.napp)
74
75			for method in ['flows', 'delete']:
76			url = f'{self.API_URL}/v2/{method}'
77
78			response_1 = api.post(url, json={'data': '123'})
79			response_2 = api.post(url)
80
81			self.assertEqual(response_1.status_code, 200)
82			self.assertEqual(response_2.status_code, 404)
83
84			self.assertEqual(mock_install_flows.call_count, 2)
85
86			@patch('napps.kytos.flow_manager.main.Main._install_flows')
87			def test_rest_add_and_delete_with_dpid(self, mock_install_flows):
88			"""Test add and delete rest method with dpid."""
89			api = get_test_client(self.napp.controller, self.napp)
90
91			for method in ['flows', 'delete']:
92			url_1 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:01'
93			url_2 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:02'
94			url_3 = f'{self.API_URL}/v2/{method}/00:00:00:00:00:00:00:03'
95
96			response_1 = api.post(url_1)
97			response_2 = api.post(url_1, json={'data': '123'})
98			response_3 = api.post(url_2, json={'data': '123'})
99			response_4 = api.post(url_3, json={'data': '123'})
100
101			self.assertEqual(response_1.status_code, 404)
102			self.assertEqual(response_2.status_code, 200)
103			if method == 'flows':
104			self.assertEqual(response_3.status_code, 404)
105			else:
106			self.assertEqual(response_3.status_code, 200)
107			self.assertEqual(response_4.status_code, 404)
108
109			self.assertEqual(mock_install_flows.call_count, 3)
110
111			def test_get_all_switches_enabled(self):
112			"""Test _get_all_switches_enabled method."""
113			switches = self.napp._get_all_switches_enabled()
114
115			self.assertEqual(switches, [self.switch_01])
116
117			@patch('napps.kytos.flow_manager.main.Main._store_changed_flows')
118			@patch('napps.kytos.flow_manager.main.Main._send_napp_event')
119			@patch('napps.kytos.flow_manager.main.Main._add_flow_mod_sent')
120			@patch('napps.kytos.flow_manager.main.Main._send_flow_mod')
121			@patch('napps.kytos.flow_manager.main.FlowFactory.get_class')
122			def test_install_flows(self, *args):
123			"""Test _install_flows method."""
124			(mock_flow_factory, mock_send_flow_mod, mock_add_flow_mod_sent,
125			mock_send_napp_event, _) = args
126			serializer = MagicMock()
127			flow = MagicMock()
128			flow_mod = MagicMock()
129
130			flow.as_of_add_flow_mod.return_value = flow_mod
131			serializer.from_dict.return_value = flow
132			mock_flow_factory.return_value = serializer
133
134			flows_dict = {'flows': [MagicMock()]}
135			switches = [self.switch_01]
136			self.napp._install_flows('add', flows_dict, switches)
137
138			mock_send_flow_mod.assert_called_with(flow.switch, flow_mod)
139			mock_add_flow_mod_sent.assert_called_with(flow_mod.header.xid,
140			flow, 'add')
141			mock_send_napp_event.assert_called_with(self.switch_01, flow, 'add')
142
143			def test_add_flow_mod_sent(self):
144			"""Test _add_flow_mod_sent method."""
145			xid = 0
146			flow = MagicMock()
147
148			self.napp._add_flow_mod_sent(xid, flow, 'add')
149
150			self.assertEqual(self.napp._flow_mods_sent[xid], (flow, 'add'))
151
152			@patch('kytos.core.buffers.KytosEventBuffer.put')
153			def test_send_flow_mod(self, mock_buffers_put):
154			"""Test _send_flow_mod method."""
155			switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
156			flow_mod = MagicMock()
157
158			self.napp._send_flow_mod(switch, flow_mod)
159
160			mock_buffers_put.assert_called()
161
162			@patch('kytos.core.buffers.KytosEventBuffer.put')
163			def test_send_napp_event(self, mock_buffers_put):
164			"""Test _send_napp_event method."""
165			switch = get_switch_mock("00:00:00:00:00:00:00:01", 0x04)
166			flow = MagicMock()
167
168			for command in ['add', 'delete', 'error']:
169			self.napp._send_napp_event(switch, flow, command)
170
171			self.assertEqual(mock_buffers_put.call_count, 3)
172
173			@patch('napps.kytos.flow_manager.main.Main._send_napp_event')
174			def test_handle_errors(self, mock_send_napp_event):
175			"""Test handle_errors method."""
176			flow = MagicMock()
177			self.napp._flow_mods_sent[0] = (flow, 'add')
178
179			message = MagicMock()
180			message.header.xid.value = 0
181			message.error_type = 2
182			message.code = 5
183			event = get_kytos_event_mock(name='..of_core..ofpt_error',
184			content={'message': message})
185			self.napp.handle_errors(event)
186
187			mock_send_napp_event.assert_called_with(flow.switch, flow, 'error',
188			error_command='add',
189			error_code=5, error_type=2)
190
191			@patch("napps.kytos.flow_manager.main.StoreHouse.get_data")
192			def test_load_flows(self, mock_storehouse):
193			"""Test load flows."""
194			self.napp._load_flows()
195			mock_storehouse.assert_called()
196
197			@patch("napps.kytos.flow_manager.main.Main._install_flows")
198			def test_resend_stored_flows(self, mock_install_flows):
199			"""Test resend stored flows."""
200			dpid = "00:00:00:00:00:00:00:01"
201			switch = get_switch_mock(dpid, 0x04)
202			mock_event = MagicMock()
203			flow = {"command": "add", "flow": MagicMock()}
204
205			flows = {"flow_list": [flow]}
206			mock_event.content = {"switch": switch}
207			self.napp.controller.switches = {dpid: switch}
208			self.napp.stored_flows = {dpid: flows}
209			self.napp.resend_stored_flows(mock_event)
210			mock_install_flows.assert_called()
211
212			@patch("napps.kytos.of_core.flow.FlowFactory.get_class")
213			@patch("napps.kytos.flow_manager.main.StoreHouse.save_flow")
214			def test_store_changed_flows(self, mock_save_flow, _):
215			"""Test store changed flows."""
216			dpid = "00:00:00:00:00:00:00:01"
217			switch = get_switch_mock(dpid, 0x04)
218			switch.id = dpid
219			flow = {
220			"priority": 17,
221			"cookie": 84114964,
222			"command": "add",
223			"match": {"dl_dst": "00:15:af:d5:38:98"},
224			}
225			match_fields = {
226			"priority": 17,
227			"cookie": 84114964,
228			"command": "add",
229			"dl_dst": "00:15:af:d5:38:98",
230			}
231			flows = {"flow": flow}
232
233			command = "add"
234			flow_list = {
235			"flow_list": [
236			{"match_fields": match_fields, "command": "delete",
237			"flow": flow}
238			]
239			}
240			self.napp.stored_flows = {dpid: flow_list}
241			self.napp._store_changed_flows(command, flows, switch)
242			mock_save_flow.assert_called()
243
244			self.napp.stored_flows = {}
245			self.napp._store_changed_flows(command, flows, switch)
246			mock_save_flow.assert_called()
247

kytos / flow_manager

Push — master ( 5bb45b...07a00f )

TestMain.test_load_flows() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like