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_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)
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_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)
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_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_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')
send_flow_mods_mocked.assert_any_call(switch_2, flows, 'delete')
def test_handle_link_up_case_1(self, deploy_to_mocked, deploy_mocked):
"""Test if handle link up do nothing when is using primary path."""
deploy_mocked.return_value = True
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=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),
]
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.primary_path
current_handle_link_up = evc.handle_link_up(backup_path[0])
self.assertEqual(deploy_mocked.call_count, 0)
self.assertEqual(deploy_to_mocked.call_count, 0)
self.assertTrue(current_handle_link_up)
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)
