build.tests.unit.models.test_link_protection

Complexity

Total Complexity

18

Size/Duplication

Total Lines	903
Duplicated Lines	26.8 %

Test Coverage

Coverage

100%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	TestLinkProtection.test_is_using_backup_path()	0	26	1
A	TestLinkProtection.test_is_using_primary_path()	0	22	1
A	TestLinkProtection.setup_method()	0	41	1
B	TestLinkProtection.test_handle_link_down_case_3()	0	65	1
A	TestLinkProtection.test_handle_link_down_case_1()	0	27	1
B	TestLinkProtection.test_handle_link_down_case_2()	58	58	1
B	TestLinkProtection.test_handle_link_down_case_4()	64	64	1
B	TestLinkProtection.test_handle_link_up_case_1()	0	52	1
A	TestLinkProtection.test_handle_link_up_case_7()	0	13	1
A	TestLinkProtection.test_handle_link_up_case_5()	0	15	1
B	TestLinkProtection.test_handle_link_up_case_2()	58	58	1
B	TestLinkProtection.test_handle_link_up_case_6()	0	130	1
B	TestLinkProtection.test_handle_link_up_case_3()	62	62	1
B	TestLinkProtection.test_handle_link_up_case_4()	0	61	1
B	TestLinkProtection.test_handle_link_up_case_8()	0	57	1
A	TestLinkProtection.test_are_unis_active()	0	13	1
A	TestLinkProtection.test_handle_interface_link()	0	55	1
A	TestLinkProtection.test_is_uni_interface_active()	0	33	1

"""Module to test the LinkProtection class."""
import sys
from unittest.mock import MagicMock, patch

from kytos.core.common import EntityStatus
from kytos.lib.helpers import get_controller_mock
from napps.kytos.mef_eline.models import EVC, Path  # NOQA pycodestyle
from napps.kytos.mef_eline.tests.helpers import (
    get_link_mocked,
    get_uni_mocked,
    id_to_interface_mock
)  # NOQA pycodestyle


sys.path.insert(0, "/var/lib/kytos/napps/..")


DEPLOY_TO_PRIMARY_PATH = (
    "napps.kytos.mef_eline.models.evc.LinkProtection.deploy_to_primary_path"
)
DEPLOY_TO_BACKUP_PATH = (
    "napps.kytos.mef_eline.models.evc.LinkProtection.deploy_to_backup_path"
)
GET_BEST_PATH = (
    "napps.kytos.mef_eline.models.path.DynamicPathManager.get_best_path"
)


class TestLinkProtection():  # pylint: disable=too-many-public-methods
    """Tests to validate LinkProtection class."""

    def setup_method(self):
        """Set up method"""
        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,
            ),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_1",
            "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,
        }
        self.evc = EVC(**attributes)

    async 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)
        assert evc.is_using_backup_path() is False
        evc.current_path = evc.backup_path
        assert evc.is_using_backup_path()

    async def test_is_using_primary_path(self):
        """Test test is using primary path."""
        primary_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}
            ),
        ]

        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_2",
            "uni_a": get_uni_mocked(is_valid=True),
            "uni_z": get_uni_mocked(is_valid=True),
            "primary_path": primary_path,
        }
        evc = EVC(**attributes)
        assert evc.is_using_primary_path() is False
        evc.current_path = evc.primary_path
        assert evc.is_using_primary_path()

    @patch("napps.kytos.mef_eline.models.evc.log")
    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy._send_flow_mods")
    @patch(DEPLOY_TO_BACKUP_PATH)
    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")
    @patch("napps.kytos.mef_eline.models.path.Path.status")
    async def test_handle_link_down_case_1(
        self,
        path_status_mocked,
        deploy_mocked,
        deploy_to_mocked,
        _send_flow_mods_mocked,
        log_mocked,
    ):
        """Test if deploy_to backup path is called."""
        deploy_mocked.return_value = True
        path_status_mocked.side_effect = [EntityStatus.DOWN, EntityStatus.UP]

        self.evc.current_path = self.evc.primary_path
        self.evc.activate()
        deploy_to_mocked.reset_mock()
        current_handle_link_down = self.evc.handle_link_down()
        assert deploy_mocked.call_count == 0
        deploy_to_mocked.assert_called_once()

        assert current_handle_link_down
        msg = f"{self.evc} deployed after link down."
        log_mocked.debug.assert_called_once_with(msg)

    @patch("napps.kytos.mef_eline.models.evc.log")

This code seems to be duplicated in your project.

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")
    @patch(DEPLOY_TO_PRIMARY_PATH)
    @patch("napps.kytos.mef_eline.models.path.Path.status")
    async 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()
        assert deploy_mocked.call_count == 0
        deploy_to_mocked.assert_called_once()
        assert current_handle_link_down
        msg = f"{evc} deployed after link down."
        log_mocked.debug.assert_called_once_with(msg)

    # pylint: disable=too-many-arguments
    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.remove_current_flows")
    @patch("napps.kytos.mef_eline.controllers.ELineController.upsert_evc")
    @patch("napps.kytos.mef_eline.models.evc.log")
    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")
    @patch(DEPLOY_TO_PRIMARY_PATH)
    @patch("napps.kytos.mef_eline.models.path.DynamicPathManager.get_paths")
    @patch("napps.kytos.mef_eline.models.path.Path.status", EntityStatus.DOWN)
    async def test_handle_link_down_case_3(
        self, get_paths_mocked, deploy_to_mocked, deploy_mocked,
        log_mocked, _, mock_remove_current
    ):
        """Test if circuit without dynamic path is return failed."""
        deploy_mocked.return_value = False
        mock_remove_current.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=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()

        assert get_paths_mocked.call_count == 0
        assert deploy_mocked.call_count == 0
        assert deploy_to_mocked.call_count == 1

        assert current_handle_link_down is False
        msg = f"Failed to re-deploy {evc} after link down."
        log_mocked.debug.assert_called_once_with(msg)

    @patch("napps.kytos.mef_eline.models.evc.log")

This code seems to be duplicated in your project.

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy_to_path")
    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy._send_flow_mods")
    @patch(DEPLOY_TO_PRIMARY_PATH)
    @patch("napps.kytos.mef_eline.models.path.Path.status", EntityStatus.DOWN)
    async def test_handle_link_down_case_4(
        self,
        deploy_to_mocked,
        _send_flow_mods_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=13,
                endpoint_b_port=14,
                metadata={"s_vlan": 6},
                status=EntityStatus.UP,
            ),
        ]
        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_8",
            "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_mocked.reset_mock()
        current_handle_link_down = evc.handle_link_down()
        assert deploy_to_mocked.call_count == 1

        assert current_handle_link_down
        msg = f"{evc} deployed after link down."
        log_mocked.debug.assert_called_with(msg)

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")
    async def test_handle_link_up_case_1(
        self,
        deploy_to_mocked,
    ):
        """Test if handle link up do nothing when is using primary path."""
        deploy_to_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_9",
            "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.primary_path
        deploy_to_mocked.reset_mock()
        current_handle_link_up = evc.handle_link_up(backup_path[0])
        assert deploy_to_mocked.call_count == 0
        assert current_handle_link_up

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")

This code seems to be duplicated in your project.

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy_to_path")
    @patch("napps.kytos.mef_eline.models.path.Path.status", EntityStatus.UP)
    async 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])
        assert deploy_mocked.call_count == 0
        assert deploy_to_path_mocked.call_count == 1
        deploy_to_path_mocked.assert_called_once_with(evc.primary_path, None)
        assert current_handle_link_up

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy")

This code seems to be duplicated in your project.

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy_to_path")
    @patch("napps.kytos.mef_eline.models.evc.EVC._install_flows")
    @patch("napps.kytos.mef_eline.models.path.Path.status", EntityStatus.UP)
    async def test_handle_link_up_case_3(
        self,
        _install_flows_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=9,
                endpoint_b_port=14,
                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_11",
            "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([])
        deploy_to_path_mocked.reset_mock()
        current_handle_link_up = evc.handle_link_up(backup_path[0])

        assert deploy_mocked.call_count == 0
        assert deploy_to_path_mocked.call_count == 1
        deploy_to_path_mocked.assert_called_once_with(evc.backup_path, None)
        assert current_handle_link_up

    @patch("napps.kytos.mef_eline.models.evc.EVCDeploy.deploy_to_path")
    @patch("napps.kytos.mef_eline.models.evc.EVC._install_flows")
    @patch("napps.kytos.mef_eline.models.path.Path.status", EntityStatus.DOWN)
    async def test_handle_link_up_case_4(self, *args):
        """Test if not path is found a dynamic path is used."""
        (
            _install_flows_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,
            ),
        ]

        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit_12",
            "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([])

        deploy_to_path_mocked.reset_mock()
        current_handle_link_up = evc.handle_link_up(backup_path[0])

        assert deploy_to_path_mocked.call_count == 1
        deploy_to_path_mocked.assert_called_once_with(old_path_dict=None)
        assert current_handle_link_up

    async def test_handle_link_up_case_5(self):
        """Test handle_link_up method."""
        return_false_mock = MagicMock(return_value=False)
        self.evc.is_using_primary_path = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.is_using_backup_path = MagicMock(return_value=True)
        assert self.evc.handle_link_up(MagicMock())

        # not possible to deploy this evc (it will not benefit from link up)
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.dynamic_backup_path = True
        self.evc.deploy_to_path = return_false_mock
        assert not self.evc.handle_link_up(MagicMock())

    # pylint: disable=too-many-statements
    async def test_handle_link_up_case_6(self):
        """Test handle_link_up method."""
        # not possible to deploy this evc (it will not benefit from link up)
        return_false_mock = MagicMock(return_value=False)
        return_true_mock = MagicMock(return_value=True)
        self.evc.is_using_primary_path = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.dynamic_backup_path = True

        self.evc.deploy_to_primary_path = MagicMock(return_value=False)
        self.evc.deploy_to_backup_path = MagicMock(return_value=False)
        self.evc.deploy_to_path = MagicMock(return_value=False)

        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_path.call_count == 1

        self.evc.is_using_primary_path = return_true_mock
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_path.call_count == 1

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_true_mock
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_path.call_count == 1

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_true_mock
        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 1
        assert self.evc.deploy_to_path.call_count == 2

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_true_mock
        self.evc.deploy_to_primary_path.return_value = True
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 2

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_true_mock
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 2

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_true_mock
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 2

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_true_mock
        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_backup_path.call_count == 1
        assert self.evc.deploy_to_path.call_count == 3

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_true_mock
        self.evc.deploy_to_backup_path.return_value = True
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_backup_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 3

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_backup_path.return_value = False
        self.evc.dynamic_backup_path = True
        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_backup_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 4

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_backup_path.return_value = False
        self.evc.dynamic_backup_path = True
        self.evc.deploy_to_path.return_value = True
        assert self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_backup_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 5

        self.evc.is_using_primary_path = return_false_mock
        self.evc.is_intra_switch = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_primary_path.return_value = False
        self.evc.is_using_backup_path = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.deploy_to_backup_path.return_value = False
        self.evc.dynamic_backup_path = False
        self.evc.deploy_to_path.return_value = False
        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_primary_path.call_count == 2
        assert self.evc.deploy_to_backup_path.call_count == 2
        assert self.evc.deploy_to_path.call_count == 5

    async def test_handle_link_up_case_7(self):
        """Test handle_link_up method."""
        return_false_mock = MagicMock(return_value=False)
        self.evc.is_using_primary_path = return_false_mock
        self.evc.primary_path.is_affected_by_link = return_false_mock
        self.evc.is_using_dynamic_path = return_false_mock
        self.evc.backup_path.is_affected_by_link = return_false_mock
        self.evc.dynamic_backup_path = True
        self.evc.activate()
        assert self.evc.is_active()
        self.evc.deploy_to_path = MagicMock(return_value=True)
        assert not self.evc.handle_link_up(MagicMock())
        assert self.evc.deploy_to_path.call_count == 0

    @patch(DEPLOY_TO_BACKUP_PATH)
    @patch(DEPLOY_TO_PRIMARY_PATH)
    async def test_handle_link_up_case_8(
        self, deploy_primary_mock, deploy_backup_mock
    ):
        """Test when UNI is UP and dinamic primary_path from
        EVC is UP as well."""
        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=13,
                endpoint_b_port=14,
                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,
            ),
        ]

        attributes = {
            "controller": get_controller_mock(),
            "name": "circuit",
            "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.handle_link_up(interface=evc.uni_a.interface)
        assert deploy_primary_mock.call_count == 1
        assert deploy_backup_mock.call_count == 0

        evc.primary_path[0].status = EntityStatus.DOWN
        evc.backup_path[1].status = EntityStatus.UP
        evc.handle_link_up(interface=evc.uni_a.interface)
        assert deploy_primary_mock.call_count == 1
        assert deploy_backup_mock.call_count == 1

    async def test_are_unis_active(self):
        """Test are_unis_active"""
        self.evc.uni_a.interface._enabled = True
        self.evc.uni_z.interface._enabled = True
        assert self.evc.are_unis_active() is True

        self.evc.uni_a.interface._active = False
        self.evc.uni_z.interface._active = False
        assert self.evc.are_unis_active() is False

        self.evc.uni_a.interface._enabled = False
        self.evc.uni_z.interface._enabled = False
        assert self.evc.are_unis_active() is False

    async def test_is_uni_interface_active(self):
        """Test is_uni_interface_active"""
        interface_a = id_to_interface_mock('00:01:1')
        interface_a.status_reason = set()
        interface_z = id_to_interface_mock('00:03:1')
        interface_z.status_reason = set()

        interface_a.status = EntityStatus.UP
        interface_z.status = EntityStatus.UP
        actual = self.evc.is_uni_interface_active(interface_a, interface_z)
        interfaces = {
            '00:01:1': {"status": "UP", "status_reason": set()},
            '00:03:1': {"status": "UP", "status_reason": set()},
        }
        expected = (True, interfaces)
        assert actual == expected

        interface_a.status = EntityStatus.DOWN
        actual = self.evc.is_uni_interface_active(interface_a, interface_z)
        interfaces = {
            '00:01:1': {'status': 'DOWN', 'status_reason': set()}
        }
        expected = (False, interfaces)
        assert actual == expected

        interface_a.status = EntityStatus.UP
        interface_z.status = EntityStatus.DOWN
        actual = self.evc.is_uni_interface_active(interface_a, interface_z)
        interfaces = {
            '00:03:1': {'status': 'DOWN', 'status_reason': set()}
        }
        expected = (False, interfaces)
        assert actual == expected

    async def test_handle_interface_link(self, monkeypatch):
        """
        Test Interface Link Up
        """
        return_false_mock = MagicMock(return_value=False)
        return_true_mock = MagicMock(return_value=True)
        interface_a = self.evc.uni_a.interface
        interface_a.enable()
        interface_b = self.evc.uni_z.interface
        interface_b.enable()
        emit_mock = MagicMock()
        monkeypatch.setattr("napps.kytos.mef_eline.models.evc.emit_event",
                            emit_mock)

        self.evc.try_to_activate = MagicMock()
        self.evc.deactivate = MagicMock()
        self.evc.sync = MagicMock()

        # Test do nothing
        self.evc.is_active = return_true_mock

        self.evc.handle_interface_link_up(interface_a)

        self.evc.try_to_activate.assert_not_called()
        self.evc.sync.assert_not_called()

        # Test deactivating
        interface_a.deactivate()

        assert emit_mock.call_count == 0
        self.evc.handle_interface_link_down(interface_a)
        assert emit_mock.call_count == 1

        self.evc.deactivate.assert_called_once()
        self.evc.sync.assert_called_once()

        # Test do nothing
        self.evc.is_active = return_false_mock

        self.evc.handle_interface_link_down(interface_a)

        self.evc.deactivate.assert_called_once()
        self.evc.sync.assert_called_once()

        # Test activating
        interface_a.activate()

        assert emit_mock.call_count == 1
        self.evc.try_to_handle_uni_as_link_up = MagicMock()
        self.evc.try_to_handle_uni_as_link_up.return_value = False
        self.evc.handle_interface_link_up(interface_a)

        self.evc.try_to_activate.assert_called_once()
        assert self.evc.sync.call_count == 2
        assert emit_mock.call_count == 2