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)
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_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())
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)
def test_as_dict(self):
"""Test path as dict."""
links = [
get_link_mocked(link_dict={"id": 3}),
get_link_mocked(link_dict={"id": 2}),
]
current_path = Path(links)
expected_dict = [{"id": 3}, {"id": 2}]
self.assertEqual(expected_dict, current_path.as_dict())
def test_status_case_4(self, requests_mocked):
# pylint: disable=unused-argument
"""Test if link status is UP."""
link1 = get_link_mocked()
link2 = get_link_mocked()
link1.id = "def"
link2.id = "abc"
links = [link1, link2]
current_path = Path(links)
self.assertEqual(current_path.status, EntityStatus.UP)
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_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_compare_same_paths(self):
"""Test compare paths with same links."""
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}),
]
path_1 = Path(links)
path_2 = Path(links)
self.assertEqual(path_1, path_2)
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"]))
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_compare_different_paths(self):
"""Test compare paths with different links."""
links_1 = [
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}),
]
links_2 = [
get_link_mocked(endpoint_a_port=12,
endpoint_b_port=11,
metadata={"s_vlan": 5}),
get_link_mocked(endpoint_a_port=14,
endpoint_b_port=16,
metadata={"s_vlan": 11}),
]
path_1 = Path(links_1)
path_2 = Path(links_2)
self.assertNotEqual(path_1, path_2)
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)
self.assertFalse(evc.is_using_primary_path())
evc.current_path = evc.primary_path
self.assertTrue(evc.is_using_primary_path())
def test_deploy_to_case_1(self, log_mocked):
"""Test if the path is equal to current_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_3",
"uni_a": get_uni_mocked(is_valid=True),
"uni_z": get_uni_mocked(is_valid=True),
"primary_path": primary_path,
}
evc = EVC(**attributes)
evc.current_path = evc.primary_path
expected_deployed = evc.deploy_to("primary_path", evc.primary_path)
expected_msg = "primary_path is equal to current_path."
log_mocked.debug.assert_called_with(expected_msg)
self.assertTrue(expected_deployed)
def test_deploy_to_case_3(self, requests_mocked):
# pylint: disable=unused-argument
"""Test deploy with one link down."""
link1 = get_link_mocked()
link2 = get_link_mocked()
link1.id = "abc"
link2.id = "def"
primary_path = [link1, link2]
attributes = {
"controller": get_controller_mock(),
"name": "circuit_5",
"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 initialization 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)
self.assertFalse(deployed)
def test_is_valid(self):
"""Test is_valid method."""
switch1 = "00:00:00:00:00:00:00:01"
switch2 = "00:00:00:00:00:00:00:02"
switch3 = "00:00:00:00:00:00:00:03"
switch4 = "00:00:00:00:00:00:00:04"
switch5 = "00:00:00:00:00:00:00:05"
switch6 = "00:00:00:00:00:00:00:06"
links1 = [
get_link_mocked(switch_a=switch1, switch_b=switch2),
get_link_mocked(switch_a=switch2, switch_b=switch3),
get_link_mocked(switch_a=switch3, switch_b=switch4),
get_link_mocked(switch_a=switch4, switch_b=switch5),
get_link_mocked(switch_a=switch5, switch_b=switch6),
]
links2 = [
get_link_mocked(switch_a=switch1, switch_b=switch2),
get_link_mocked(switch_a=switch3, switch_b=switch2),
get_link_mocked(switch_a=switch3, switch_b=switch4),
]
for links, switch_a, switch_z, expected in (
(links1, switch1, switch6, True),
(links2, switch1, switch4, False),
(links1, switch2, switch6, False),
):
with self.subTest(
links=links,
switch_a=switch_a,
switch_z=switch_z,
expected=expected,
):
path = Path(links)
if expected:
self.assertEqual(path.is_valid(switch_a, switch_z),
expected)
else:
with self.assertRaises(InvalidPath):
path.is_valid(switch_a, switch_z)
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=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)
# storehouse initialization mock
evc._storehouse.box = Mock() # pylint: disable=protected-access
evc._storehouse.box.data = {} # pylint: disable=protected-access
evc.current_path = Path([])
deploy_to_path_mocked.reset_mock()
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_error(self, *args):
"""Test if all methods is ignored when the should_deploy is false."""
# pylint: disable=too-many-locals
(
sync_mock,
remove_current_flows,
should_deploy_mock,
install_nni_flows,
choose_vlans_mock,
discover_new_paths,
log_mock,
) = args
install_nni_flows.side_effect = FlowModException
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,
"queue_id": 5,
}
# Setup path to deploy
path = Path()
path.append(primary_links[0])
path.append(primary_links[1])
evc = EVC(**attributes)
deployed = evc.deploy_to_path(path)
self.assertEqual(discover_new_paths.call_count, 0)
self.assertEqual(should_deploy_mock.call_count, 1)
self.assertEqual(install_nni_flows.call_count, 1)
self.assertEqual(choose_vlans_mock.call_count, 1)
self.assertEqual(log_mock.error.call_count, 1)
self.assertEqual(sync_mock.call_count, 0)
self.assertEqual(remove_current_flows.call_count, 2)
self.assertFalse(deployed)
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
# storehouse mock
evc._storehouse.box = Mock() # pylint: disable=protected-access
evc._storehouse.box.data = {} # pylint: disable=protected-access
deploy_to_mocked.reset_mock()
current_handle_link_down = evc.handle_link_down()
self.assertEqual(deploy_to_mocked.call_count, 1)
self.assertTrue(current_handle_link_down)
msg = f"{evc} deployed after link down."
log_mocked.debug.assert_called_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_paths_mocked,
should_deploy_mock,
activate_mock,
install_uni_flows_mock,
install_nni_flows,
chose_vlans_mock,
log_mock,
_,
requests_mock,
) = args
response = MagicMock()
response.status_code = 201
requests_mock.return_value = response
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": False,
}
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_paths_mocked.return_value = [dynamic_backup_path]
deployed = evc.deploy_to_path()
self.assertEqual(should_deploy_mock.call_count, 1)
self.assertEqual(discover_new_paths_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)
log_mock.info.assert_called_with(f"{evc} was deployed.")
self.assertTrue(deployed)
def test_remove_current_flows(self, send_flow_mods_mocked):
"""Test remove current flows."""
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,
)
switch_a = Switch("00:00:00:00:00:01")
switch_b = Switch("00:00:00:00:00:02")
switch_c = Switch("00:00:00:00:00:03")
attributes = {
"controller":
get_controller_mock(),
"name":
"custom_name",
"uni_a":
uni_a,
"uni_z":
uni_z,
"active":
True,
"enabled":
True,
"primary_links": [
get_link_mocked(
switch_a=switch_a,
switch_b=switch_b,
endpoint_a_port=9,
endpoint_b_port=10,
metadata={"s_vlan": 5},
),
get_link_mocked(
switch_a=switch_b,
switch_b=switch_c,
endpoint_a_port=11,
endpoint_b_port=12,
metadata={"s_vlan": 6},
),
],
}
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 = evc.primary_links
evc.remove_current_flows()
self.assertEqual(send_flow_mods_mocked.call_count, 5)
self.assertFalse(evc.is_active())
flows = [{
"cookie": evc.get_cookie(),
"cookie_mask": 18446744073709551615
}]
switch_1 = evc.primary_links[0].endpoint_a.switch
switch_2 = evc.primary_links[0].endpoint_b.switch
send_flow_mods_mocked.assert_any_call(switch_1,
flows,
'delete',
force=True)
send_flow_mods_mocked.assert_any_call(switch_2,
flows,
'delete',
force=True)
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,
choose_vlans_mock,
discover_new_paths,
log_mock,
requests_mock,
) = args
response = MagicMock()
response.status_code = 201
requests_mock.return_value = response
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_paths.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(choose_vlans_mock.call_count, 0)
self.assertEqual(log_mock.info.call_count, 0)
self.assertEqual(sync_mock.call_count, 1)
self.assertFalse(deployed)
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_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([])
# storehouse mock
evc._storehouse.box = Mock() # pylint: disable=protected-access
evc._storehouse.box.data = {} # pylint: disable=protected-access
deploy_to_path_mocked.reset_mock()
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_install_nni_flows(send_flow_mods_mock):
"""Test install nni flows method.
This test will verify the flows send to the send_flow_mods method.
"""
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,
"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)
# pylint: disable=protected-access
evc._install_nni_flows(attributes["primary_links"])
in_vlan = evc.primary_links[0].get_metadata("s_vlan").value
out_vlan = evc.primary_links[-1].get_metadata("s_vlan").value
in_port = evc.primary_links[0].endpoint_b.port_number
out_port = evc.primary_links[-1].endpoint_a.port_number
expected_flow_mods = [
{
"match": {
"in_port": in_port,
"dl_vlan": in_vlan
},
"cookie":
evc.get_cookie(),
"actions": [
{
"action_type": "set_vlan",
"vlan_id": out_vlan
},
{
"action_type": "output",
"port": out_port
},
],
},
{
"match": {
"in_port": out_port,
"dl_vlan": out_vlan
},
"cookie":
evc.get_cookie(),
"actions": [
{
"action_type": "set_vlan",
"vlan_id": in_vlan
},
{
"action_type": "output",
"port": in_port
},
],
},
]
switch = evc.primary_links[0].endpoint_b.switch
send_flow_mods_mock.assert_called_once_with(switch, expected_flow_mods)
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,
_,
requests_mock,
) = args
response = MagicMock()
response.status_code = 201
requests_mock.return_value = response
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,
"queue_id": 5,
}
# Setup path to deploy
path = Path()
path.append(primary_links[0])
path.append(primary_links[1])
evc = EVC(**attributes)
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_with(f"{evc} was deployed.")
self.assertTrue(deployed)
