def test_prepare_pop_flow(self):
        """Test prepare pop flow  method."""
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(interface_port=1, is_valid=True),
            "uni_z": get_uni_mocked(interface_port=2, is_valid=True),
        }
        evc = EVC(**attributes)
        interface_a = evc.uni_a.interface
        interface_z = evc.uni_z.interface
        in_vlan = 10

        # pylint: disable=protected-access
        flow_mod = evc._prepare_pop_flow(interface_a, interface_z, in_vlan)

        expected_flow_mod = {
            'match': {
                'in_port': interface_a.port_number,
                'dl_vlan': in_vlan
            },
            'cookie':
            evc.get_cookie(),
            'actions': [{
                'action_type': 'pop_vlan'
            }, {
                'action_type': 'output',
                'port': interface_z.port_number
            }]
        }
        self.assertEqual(expected_flow_mod, flow_mod)
    def test_prepare_flow_mod(self):
        """Test prepare flow_mod method."""
        interface_a = Interface('eth0', 1, Mock(spec=Switch))
        interface_z = Interface('eth1', 3, Mock(spec=Switch))
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_links": [get_link_mocked(),
                              get_link_mocked()],
            "enabled": True,
            "active": True
        }
        evc = EVC(**attributes)

        # pylint: disable=protected-access
        flow_mod = evc._prepare_flow_mod(interface_a, interface_z)
        expected_flow_mod = {
            'match': {
                'in_port': interface_a.port_number
            },
            'cookie': evc.get_cookie(),
            'actions': [{
                'action_type': 'output',
                'port': interface_z.port_number
            }]
        }
        self.assertEqual(expected_flow_mod, flow_mod)
Exemple #3
0
    def test_is_using_backup_path(self):
        """Test test is using backup path."""

        attributes = {
            "controller":
            get_controller_mock(),
            "name":
            "circuit_1",
            "uni_a":
            get_uni_mocked(is_valid=True),
            "uni_z":
            get_uni_mocked(is_valid=True),
            "backup_path": [
                get_link_mocked(
                    endpoint_a_port=10,
                    endpoint_b_port=9,
                    metadata={"s_vlan": 5},
                ),
                get_link_mocked(
                    endpoint_a_port=12,
                    endpoint_b_port=11,
                    metadata={"s_vlan": 6},
                ),
            ],
        }

        evc = EVC(**attributes)
        self.assertFalse(evc.is_using_backup_path())
        evc.current_path = evc.backup_path
        self.assertTrue(evc.is_using_backup_path())
Exemple #4
0
    def test_deploy_to_case_2(
        self,
        install_uni_flows_mocked,
        install_nni_flows_mocked,
        deploy_mocked,
        _,
        requests_mock,
    ):
        """Test deploy with all links up."""
        deploy_mocked.return_value = True
        response = MagicMock()
        response.status_code = 201
        requests_mock.return_value = response

        primary_path = [
            get_link_mocked(status=EntityStatus.UP),
            get_link_mocked(status=EntityStatus.UP),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_4",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "enabled": True,
        }
        evc = EVC(**attributes)

        deployed = evc.deploy_to("primary_path", evc.primary_path)
        install_uni_flows_mocked.assert_called_with(evc.primary_path)
        install_nni_flows_mocked.assert_called_with(evc.primary_path)
        self.assertTrue(deployed)
    def test_deploy_to_case_2(self, install_uni_flows_mocked,
                              install_nni_flows_mocked, deploy_mocked):
        """Test deploy with all links up."""
        deploy_mocked.return_value = True

        primary_path = [
            get_link_mocked(status=EntityStatus.UP),
            get_link_mocked(status=EntityStatus.UP)
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "enabled": True
        }
        evc = EVC(**attributes)

        # storehouse mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        deployed = evc.deploy_to('primary_path', evc.primary_path)
        install_uni_flows_mocked.assert_called_with(evc.primary_path)
        install_nni_flows_mocked.assert_called_with(evc.primary_path)
        self.assertTrue(deployed)
Exemple #6
0
    def test_prepare_pop_flow(self):
        """Test prepare pop flow  method."""
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(interface_port=1, is_valid=True),
            "uni_z": get_uni_mocked(interface_port=2, is_valid=True),
        }
        evc = EVC(**attributes)
        interface_a = evc.uni_a.interface
        interface_z = evc.uni_z.interface
        in_vlan = 10

        # pylint: disable=protected-access
        flow_mod = evc._prepare_pop_flow(interface_a, interface_z, None,
                                         in_vlan)

        expected_flow_mod = {
            "match": {
                "in_port": interface_a.port_number,
                "dl_vlan": in_vlan
            },
            "cookie":
            evc.get_cookie(),
            "actions": [
                {
                    "action_type": "pop_vlan"
                },
                {
                    "action_type": "output",
                    "port": interface_z.port_number
                },
            ],
        }
        self.assertEqual(expected_flow_mod, flow_mod)
Exemple #7
0
    def test_deploy_to_backup_path1(self, discover_new_paths_mocked,
                                    deploy_to_path_mocked):
        """Test deployment when dynamic_backup_path is False in same switch"""
        uni_a = get_uni_mocked(interface_port=2, tag_value=82, is_valid=True)
        uni_z = get_uni_mocked(interface_port=3, tag_value=83, is_valid=True)

        switch = Mock(spec=Switch)
        uni_a.interface.switch = switch
        uni_z.interface.switch = switch

        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": uni_a,
            "uni_z": uni_z,
            "enabled": True,
            "dynamic_backup_path": False
        }

        evc = EVC(**attributes)
        discover_new_paths_mocked.return_value = []
        deploy_to_path_mocked.return_value = True

        # storehouse initialization mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        deployed = evc.deploy_to_backup_path()

        deploy_to_path_mocked.assert_called_once_with()
        self.assertEqual(deployed, True)
    def test_handle_link_up_case_4(self, *args):
        """Test if not path is found a dynamic path is used."""
        (_install_uni_flows_mocked, _install_nni_flows_mocked,
         get_best_path_mocked, deploy_to_path_mocked) = args

        deploy_to_path_mocked.return_value = True

        primary_path = [
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.UP),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.DOWN),
        ]
        backup_path = [
            get_link_mocked(endpoint_a_port=13,
                            endpoint_b_port=14,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.DOWN),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.DOWN),
        ]

        # Setup best_path mock
        best_path = Path()
        best_path.append(primary_path[0])
        get_best_path_mocked.return_value = best_path

        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
            "dynamic_backup_path": True
        }

        evc = EVC(**attributes)
        evc.current_path = Path([])

        # storehouse mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        current_handle_link_up = evc.handle_link_up(backup_path[0])

        self.assertEqual(get_best_path_mocked.call_count, 0)
        self.assertEqual(deploy_to_path_mocked.call_count, 1)
        deploy_to_path_mocked.assert_called_once_with()
        self.assertTrue(current_handle_link_up)
    def test_handle_link_down_case_3(
        self, get_paths_mocked, deploy_to_mocked, deploy_mocked, log_mocked
    ):
        """Test if circuit without dynamic path is return failed."""
        deploy_mocked.return_value = False
        deploy_to_mocked.return_value = False
        primary_path = [
            get_link_mocked(
                endpoint_a_port=9,
                endpoint_b_port=10,
                metadata={"s_vlan": 5},
                status=EntityStatus.DOWN,
            ),
            get_link_mocked(
                endpoint_a_port=11,
                endpoint_b_port=12,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        backup_path = [
            get_link_mocked(
                endpoint_a_port=9,
                endpoint_b_port=10,
                metadata={"s_vlan": 5},
                status=EntityStatus.DOWN,
            ),
            get_link_mocked(
                endpoint_a_port=13,
                endpoint_b_port=14,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_7",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
        }

        evc = EVC(**attributes)
        evc.current_path = evc.backup_path
        deploy_to_mocked.reset_mock()
        current_handle_link_down = evc.handle_link_down()

        self.assertEqual(get_paths_mocked.call_count, 0)
        self.assertEqual(deploy_mocked.call_count, 0)
        self.assertEqual(deploy_to_mocked.call_count, 1)

        self.assertFalse(current_handle_link_down)
        msg = f"Failed to re-deploy {evc} after link down."
        log_mocked.debug.assert_called_once_with(msg)
Exemple #10
0
    def test_handle_link_down_case_4(self, deploy_to_mocked,
                                     _send_flow_mods_mocked,
                                     get_best_path_mocked, deploy_mocked,
                                     log_mocked):
        """Test if circuit with dynamic path is return success."""
        deploy_mocked.return_value = True
        deploy_to_mocked.return_value = False
        primary_path = [
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.DOWN),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.UP),
        ]
        backup_path = [
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.DOWN),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.UP),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
            "dynamic_backup_path": True
        }

        evc = EVC(**attributes)
        evc.current_path = evc.backup_path

        # storehouse mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        current_handle_link_down = evc.handle_link_down()

        self.assertEqual(get_best_path_mocked.call_count, 6)
        self.assertEqual(deploy_to_mocked.call_count, 1)
        deploy_to_mocked.assert_called_once_with('primary_path',
                                                 evc.primary_path)
        self.assertTrue(current_handle_link_down)
        msg = f"{evc} deployed after link down."
        log_mocked.debug.assert_called_with(msg)
Exemple #11
0
    def test_handle_link_down_case_2(self, path_status_mocked,
                                     deploy_to_mocked, deploy_mocked,
                                     log_mocked):
        """Test if deploy_to backup path is called."""
        deploy_mocked.return_value = True
        deploy_to_mocked.return_value = True
        path_status_mocked.side_effect = [EntityStatus.UP, EntityStatus.DOWN]
        primary_path = [
            get_link_mocked(
                endpoint_a_port=7,
                endpoint_b_port=8,
                metadata={"s_vlan": 5},
                status=EntityStatus.UP,
            ),
            get_link_mocked(
                endpoint_a_port=11,
                endpoint_b_port=12,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        backup_path = [
            get_link_mocked(
                endpoint_a_port=7,
                endpoint_b_port=10,
                metadata={"s_vlan": 5},
                status=EntityStatus.DOWN,
            ),
            get_link_mocked(
                endpoint_a_port=15,
                endpoint_b_port=12,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_13",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
        }

        evc = EVC(**attributes)
        evc.current_path = evc.backup_path
        deploy_to_mocked.reset_mock()
        current_handle_link_down = evc.handle_link_down()
        self.assertEqual(deploy_mocked.call_count, 0)
        deploy_to_mocked.assert_called_once()
        self.assertTrue(current_handle_link_down)
        msg = f"{evc} deployed after link down."
        log_mocked.debug.assert_called_once_with(msg)
    def test_deploy_without_path_case1(self, *args):
        """Test if not path is found a dynamic path is used."""
        # pylint: disable=too-many-locals
        (discover_new_path_mocked, should_deploy_mock, activate_mock,
         install_uni_flows_mock, install_nni_flows, chose_vlans_mock,
         log_mock) = args

        should_deploy_mock.return_value = False
        uni_a = get_uni_mocked(interface_port=2,
                               tag_value=82,
                               switch_id="switch_uni_a",
                               is_valid=True)
        uni_z = get_uni_mocked(interface_port=3,
                               tag_value=83,
                               switch_id="switch_uni_z",
                               is_valid=True)

        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": uni_a,
            "uni_z": uni_z,
            "enabled": True,
            "dynamic_backup_path": True
        }

        dynamic_backup_path = Path([
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5}),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6})
        ])

        evc = EVC(**attributes)
        discover_new_path_mocked.return_value = dynamic_backup_path

        # storehouse initialization mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        deployed = evc.deploy_to_path()

        self.assertEqual(should_deploy_mock.call_count, 1)
        self.assertEqual(discover_new_path_mocked.call_count, 1)
        self.assertEqual(activate_mock.call_count, 1)
        self.assertEqual(install_uni_flows_mock.call_count, 1)
        self.assertEqual(install_nni_flows.call_count, 1)
        self.assertEqual(chose_vlans_mock.call_count, 1)
        self.assertEqual(log_mock.info.call_count, 1)
        self.assertTrue(deployed)
    def test_handle_link_up_case_3(self, _install_uni_flows_mocked,
                                   _install_nni_flows_mocked,
                                   get_best_path_mocked, deploy_to_path_mocked,
                                   deploy_mocked):
        """Test if it is deployed after the backup is up."""
        deploy_mocked.return_value = True
        deploy_to_path_mocked.return_value = True
        primary_path = [
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.DOWN),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.UP),
        ]
        backup_path = [
            get_link_mocked(endpoint_a_port=13,
                            endpoint_b_port=14,
                            metadata={"s_vlan": 5},
                            status=EntityStatus.DOWN),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6},
                            status=EntityStatus.UP),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
            "dynamic_backup_path": True
        }

        evc = EVC(**attributes)

        # storehouse initialization mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        evc.current_path = Path([])
        current_handle_link_up = evc.handle_link_up(backup_path[0])

        self.assertEqual(get_best_path_mocked.call_count, 0)
        self.assertEqual(deploy_mocked.call_count, 0)
        self.assertEqual(deploy_to_path_mocked.call_count, 1)
        deploy_to_path_mocked.assert_called_once_with(evc.backup_path)
        self.assertTrue(current_handle_link_up)
    def test_deploy_successfully(self, *args):
        """Test if all methods to deploy are called."""
        # pylint: disable=too-many-locals
        (should_deploy_mock, activate_mock, install_uni_flows_mock,
         install_nni_flows, chose_vlans_mock, log_mock) = args

        should_deploy_mock.return_value = True
        uni_a = get_uni_mocked(interface_port=2,
                               tag_value=82,
                               switch_id="switch_uni_a",
                               is_valid=True)
        uni_z = get_uni_mocked(interface_port=3,
                               tag_value=83,
                               switch_id="switch_uni_z",
                               is_valid=True)

        primary_links = [
            get_link_mocked(endpoint_a_port=9,
                            endpoint_b_port=10,
                            metadata={"s_vlan": 5}),
            get_link_mocked(endpoint_a_port=11,
                            endpoint_b_port=12,
                            metadata={"s_vlan": 6})
        ]

        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": uni_a,
            "uni_z": uni_z,
            "primary_links": primary_links
        }
        # Setup path to deploy
        path = Path()
        path.append(primary_links[0])
        path.append(primary_links[1])

        evc = EVC(**attributes)

        # storehouse mock
        evc._storehouse.box = Mock()  # pylint: disable=protected-access
        evc._storehouse.box.data = {}  # pylint: disable=protected-access

        deployed = evc.deploy_to_path(path)

        self.assertEqual(should_deploy_mock.call_count, 1)
        self.assertEqual(activate_mock.call_count, 1)
        self.assertEqual(install_uni_flows_mock.call_count, 1)
        self.assertEqual(install_nni_flows.call_count, 1)
        self.assertEqual(chose_vlans_mock.call_count, 1)
        log_mock.info.assert_called_once_with(f"{evc} was deployed.")
        self.assertTrue(deployed)
Exemple #15
0
 def test_get_id_from_cookie():
     """Test get_id_from_cookie."""
     attributes = {
         "controller": get_controller_mock(),
         "name": "circuit_name",
         "enable": True,
         "uni_a": get_uni_mocked(is_valid=True),
         "uni_z": get_uni_mocked(is_valid=True)
     }
     evc = EVC(**attributes)
     evc_id = evc.id
     assert evc_id
     assert evc.get_id_from_cookie(evc.get_cookie()) == evc_id
    def test_send_flow_mods_case1(self, requests_mock):
        """Test if you are sending flow_mods."""
        flow_mods = {"id": 20}
        switch = Mock(spec=Switch, id=1)

        # pylint: disable=protected-access
        EVC._send_flow_mods(switch, flow_mods)

        expected_endpoint = f"{MANAGER_URL}/flows/{switch.id}"
        expected_data = {"flows": flow_mods}
        self.assertEqual(requests_mock.post.call_count, 1)
        requests_mock.post.assert_called_once_with(expected_endpoint,
                                                   json=expected_data)
Exemple #17
0
 def test_update_queue(self, _sync_mock):
     """Test if evc is set to redeploy."""
     attributes = {
         "controller": get_controller_mock(),
         "name": "circuit_name",
         "enable": True,
         "uni_a": get_uni_mocked(is_valid=True),
         "uni_z": get_uni_mocked(is_valid=True),
     }
     update_dict = {"queue_id": 3}
     evc = EVC(**attributes)
     _, redeploy = evc.update(**update_dict)
     self.assertTrue(redeploy)
Exemple #18
0
 def test_update_disable(self, _sync_mock):
     """Test if evc is disabled."""
     attributes = {
         "controller": get_controller_mock(),
         "name": "circuit_name",
         "enable": True,
         "uni_a": get_uni_mocked(is_valid=True),
         "uni_z": get_uni_mocked(is_valid=True),
     }
     update_dict = {"enable": False}
     evc = EVC(**attributes)
     evc.update(**update_dict)
     self.assertIs(evc.is_enabled(), False)
    def test_should_deploy_case1(log_mock):
        """Test should deploy method without primary links."""
        log_mock.debug.return_value = True
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }

        evc = EVC(**attributes)
        evc.should_deploy()
        log_mock.debug.assert_called_with('Path is empty.')
Exemple #20
0
    def test_handle_link_up_case_2(self, deploy_to_path_mocked, deploy_mocked):
        """Test if it is changing from backup_path to primary_path."""
        deploy_mocked.return_value = True
        deploy_to_path_mocked.return_value = True
        primary_path = [
            get_link_mocked(
                endpoint_a_port=9,
                endpoint_b_port=10,
                metadata={"s_vlan": 5},
                status=EntityStatus.UP,
            ),
            get_link_mocked(
                endpoint_a_port=11,
                endpoint_b_port=12,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        backup_path = [
            get_link_mocked(
                endpoint_a_port=9,
                endpoint_b_port=14,
                metadata={"s_vlan": 5},
                status=EntityStatus.UP,
            ),
            get_link_mocked(
                endpoint_a_port=15,
                endpoint_b_port=12,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_10",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
            "backup_path": backup_path,
            "enabled": True,
            "dynamic_backup_path": True,
        }

        evc = EVC(**attributes)
        evc.current_path = evc.backup_path
        deploy_to_path_mocked.reset_mock()
        current_handle_link_up = evc.handle_link_up(primary_path[0])
        self.assertEqual(deploy_mocked.call_count, 0)
        self.assertEqual(deploy_to_path_mocked.call_count, 1)
        deploy_to_path_mocked.assert_called_once_with(evc.primary_path)
        self.assertTrue(current_handle_link_up)
    def test_prepare_push_flow(self):
        """Test prepare push flow method."""
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(interface_port=1, is_valid=True),
            "uni_z": get_uni_mocked(interface_port=2, is_valid=True),
        }
        evc = EVC(**attributes)
        interface_a = evc.uni_a.interface
        interface_z = evc.uni_z.interface
        out_vlan_a = 20

        for in_vlan_a in (10, None):
            for in_vlan_z in (3, None):
                with self.subTest(in_vlan_a=in_vlan_a, in_vlan_z=in_vlan_z):
                    # pylint: disable=protected-access
                    flow_mod = evc._prepare_push_flow(interface_a, interface_z,
                                                      in_vlan_a, out_vlan_a,
                                                      in_vlan_z)

                    expected_flow_mod = {
                        'match': {'in_port': interface_a.port_number},
                        'cookie': evc.get_cookie(),
                        'actions': [
                            {'action_type': 'push_vlan', 'tag_type': 's'},
                            {'action_type': 'set_vlan', 'vlan_id': out_vlan_a},
                            {
                                'action_type': 'output',
                                'port': interface_z.port_number
                            }
                        ]
                    }
                    if in_vlan_a and in_vlan_z:
                        expected_flow_mod['match']['dl_vlan'] = in_vlan_a
                        expected_flow_mod['actions'].insert(0, {
                            'action_type': 'set_vlan', 'vlan_id': in_vlan_z
                        })
                    elif in_vlan_a:
                        expected_flow_mod['match']['dl_vlan'] = in_vlan_a
                        expected_flow_mod['actions'].insert(0, {
                            'action_type': 'pop_vlan'
                        })
                    elif in_vlan_z:
                        expected_flow_mod['actions'].insert(0, {
                            'action_type': 'set_vlan', 'vlan_id': in_vlan_z
                        })
                        expected_flow_mod['actions'].insert(0, {
                            'action_type': 'push_vlan', 'tag_type': 'c'
                        })
                    self.assertEqual(expected_flow_mod, flow_mod)
    def test_should_deploy_case2(self, log_mock):
        """Test should deploy method with disable circuit."""
        log_mock.debug.return_value = True
        attributes = {
            "controller": get_controller_mock(),
            "name": "custom_name",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_links": [get_link_mocked(), get_link_mocked()]
        }
        evc = EVC(**attributes)

        self.assertFalse(evc.should_deploy(attributes['primary_links']))
        log_mock.debug.assert_called_with(f'{evc} is disabled.')
 def test_should_deploy_case4(self, log_mock):
     """Test should deploy method with enabled and active circuit."""
     log_mock.debug.return_value = True
     attributes = {
         "controller": get_controller_mock(),
         "name": "custom_name",
         "uni_a": get_uni_mocked(is_valid=True),
         "uni_z": get_uni_mocked(is_valid=True),
         "primary_links": [get_link_mocked(), get_link_mocked()],
         "enabled": True,
         "active": True
     }
     evc = EVC(**attributes)
     self.assertFalse(evc.should_deploy(attributes['primary_links']))
Exemple #24
0
 def test_should_deploy_case3(self, log_mock):
     """Test should deploy method with enabled and not active circuit."""
     log_mock.debug.return_value = True
     attributes = {
         "controller": get_controller_mock(),
         "name": "custom_name",
         "uni_a": get_uni_mocked(is_valid=True),
         "uni_z": get_uni_mocked(is_valid=True),
         "primary_links": [get_link_mocked(), get_link_mocked()],
         "enabled": True,
     }
     evc = EVC(**attributes)
     self.assertTrue(evc.should_deploy(attributes["primary_links"]))
     log_mock.debug.assert_called_with(f"{evc} will be deployed.")
    def test_deploy_fail(self, *args):
        """Test if all methods is ignored when the should_deploy is false."""
        # pylint: disable=too-many-locals
        (sync_mock, should_deploy_mock, activate_mock, install_uni_flows_mock,
         install_nni_flows, chose_vlans_mock, discover_new_path,
         log_mock) = args

        uni_a = get_uni_mocked(interface_port=2,
                               tag_value=82,
                               switch_id="switch_uni_a",
                               switch_dpid="switch_dpid_uni_a",
                               is_valid=True)
        uni_z = get_uni_mocked(interface_port=3,
                               tag_value=83,
                               switch_id="switch_uni_z",
                               switch_dpid="switch_dpid_uni_a",
                               is_valid=True)

        attributes = {
            "controller":
            get_controller_mock(),
            "name":
            "custom_name",
            "uni_a":
            uni_a,
            "uni_z":
            uni_z,
            "primary_links": [
                get_link_mocked(endpoint_a_port=9,
                                endpoint_b_port=10,
                                metadata={"s_vlan": 5}),
                get_link_mocked(endpoint_a_port=11,
                                endpoint_b_port=12,
                                metadata={"s_vlan": 6})
            ]
        }

        evc = EVC(**attributes)
        deployed = evc.deploy_to_path()

        self.assertEqual(discover_new_path.call_count, 1)
        self.assertEqual(should_deploy_mock.call_count, 1)
        self.assertEqual(activate_mock.call_count, 0)
        self.assertEqual(install_uni_flows_mock.call_count, 0)
        self.assertEqual(install_nni_flows.call_count, 0)
        self.assertEqual(chose_vlans_mock.call_count, 0)
        self.assertEqual(log_mock.info.call_count, 0)
        self.assertEqual(sync_mock.call_count, 1)
        self.assertFalse(deployed)
Exemple #26
0
    def test_send_flow_mods_case2(self, requests_mock):
        """Test if you are sending flow_mods."""
        flow_mods = {"id": 20}
        switch = Mock(spec=Switch, id=1)
        response = MagicMock()
        response.status_code = 201
        requests_mock.post.return_value = response

        # pylint: disable=protected-access
        EVC._send_flow_mods(switch, flow_mods, command='delete', force=True)

        expected_endpoint = f"{MANAGER_URL}/delete/{switch.id}"
        expected_data = {"flows": flow_mods, "force": True}
        self.assertEqual(requests_mock.post.call_count, 1)
        requests_mock.post.assert_called_once_with(expected_endpoint,
                                                   json=expected_data)
Exemple #27
0
    def test_new_circuit_with_frequency(self, validate_mock,
                                        scheduler_add_job_mock,
                                        trigger_mock):
        """Test if add new circuit with frequency."""
        scheduler_add_job_mock.return_value = True
        validate_mock.return_value = True

        frequency = "* * * * *"
        circuit_scheduler = CircuitSchedule(action="create",
                                            frequency=frequency)

        trigger = CronTrigger.from_crontab(circuit_scheduler.frequency,
                                           timezone=utc)
        trigger_mock.return_value = trigger

        options = {"controller": get_controller_mock(),
                   "name": 'my evc1',
                   "uni_a": 'uni_a',
                   "uni_z": 'uni_z',
                   "start_date": "2019-08-09T19:25:06",
                   "circuit_scheduler": [circuit_scheduler]
                   }
        evc = EVC(**options)
        self.scheduler.add(evc)
        expected_parameters = {
            "id": circuit_scheduler.id,
            "end_date": None,
            "start_date": datetime.datetime(
                2019, 8, 9, 19, 25, 6, 0, tzinfo=datetime.timezone.utc)
        }
        scheduler_add_job_mock.assert_called_once_with(evc.deploy, trigger,
                                                       **expected_parameters)
Exemple #28
0
    def test_new_circuit_with_interval(self, validate_mock,
                                       scheduler_add_job_mock):
        """Test if add new circuit with interval."""
        scheduler_add_job_mock.return_value = True
        validate_mock.return_value = True
        interval = {
            'hours': 2,
            'minutes': 3
        }
        circuit_scheduler = CircuitSchedule(action="create", interval=interval)
        options = {"controller": get_controller_mock(),
                   "name": 'my evc1',
                   "uni_a": 'uni_a',
                   "uni_z": 'uni_z',
                   "start_date": "2019-08-09T19:25:06",
                   "circuit_scheduler": [circuit_scheduler]
                   }
        evc = EVC(**options)
        self.scheduler.add(evc)

        expected_parameters = {
            "id": circuit_scheduler.id,
            "hours": 2,
            "minutes": 3,
            "end_date": None,
            "start_date": datetime.datetime(
                2019, 8, 9, 19, 25, 6, 0, tzinfo=datetime.timezone.utc)
        }
        scheduler_add_job_mock.assert_called_once_with(evc.deploy, 'interval',
                                                       **expected_parameters)
Exemple #29
0
    def evc_from_dict(self, evc_dict):
        """Convert some dict values to instance of EVC classes.

        This method will convert: [UNI, Link]
        """
        data = evc_dict.copy()  # Do not modify the original dict

        for attribute, value in data.items():

            if 'uni' in attribute:
                try:
                    data[attribute] = self.uni_from_dict(value)
                except ValueError as exc:
                    raise ValueError(f'Error creating UNI: {exc}')

            if attribute == 'circuit_scheduler':
                data[attribute] = []
                for schedule in value:
                    data[attribute].append(CircuitSchedule.from_dict(schedule))

            if 'link' in attribute:
                if value:
                    data[attribute] = self.link_from_dict(value)

            if 'path' in attribute and attribute != 'dynamic_backup_path':
                if value:
                    data[attribute] = [
                        self.link_from_dict(link) for link in value
                    ]

        return EVC(self.controller, **data)
Exemple #30
0
    def test_get_id_from_cookie_with_leading_zeros():
        """Test get_id_from_cookie with leading zeros."""

        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_name",
            "enable": True,
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True)
        }
        evc = EVC(**attributes)
        evc_id = "0a2d672d99ff41"
        # pylint: disable=protected-access
        evc._id = evc_id
        # pylint: enable=protected-access
        assert EVC.get_id_from_cookie(evc.get_cookie()) == evc_id