def test_without_uni_z(self): """Test if the EVC raises and error with UNI Z is required.""" attributes = { "controller": get_controller_mock(), "name": "circuit_name", "uni_a": get_uni_mocked(is_valid=True) } error_message = "uni_z is required." with self.assertRaises(ValueError) as handle_error: EVC(**attributes) self.assertEqual(str(handle_error.exception), error_message)
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 setUp(self): """Initialize before tests are executed.""" self.controller = get_controller_mock() self.start = datetime.datetime.now(pytz.utc) self.start += datetime.timedelta(days=1) self.end = self.start + datetime.timedelta(hours=6) self.items = ["01:23:45:67:89:ab:cd:ef"] self.maintenance = MW(self.start, self.end, self.controller, items=self.items)
def test_with_invalid_uni_a(self): """Test if the EVC raises and error with invalid UNI A.""" attributes = { "controller": get_controller_mock(), "name": "circuit_name", "uni_a": get_uni_mocked(tag_value=82) } error_message = "VLAN tag 82 is not available in uni_a" with self.assertRaises(ValueError) as handle_error: EVC(**attributes) self.assertEqual(str(handle_error.exception), error_message)
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_circuit_representation(self): """Test the method __repr__.""" attributes = { "controller": get_controller_mock(), "name": "circuit_name", "uni_a": get_uni_mocked(is_valid=True), "uni_z": get_uni_mocked(is_valid=True) } evc = EVC(**attributes) expected_value = f'EVC({evc.id}, {evc.name})' self.assertEqual(str(evc), expected_value)
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)
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_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.')
def setUp(self): """Execute steps before each tests. Set the server_name_url from kytos/of_core """ self.server_name_url = 'http://localhost:8181/api/kytos/of_core' patch('kytos.core.helpers.run_on_thread', lambda x: x).start() # pylint: disable=bad-option-value from napps.kytos.of_core.main import Main self.addCleanup(patch.stopall) self.napp = Main(get_controller_mock()) self.patched_events = []
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']))
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)
def test_comparison_method(self): """Test the method __eq__.""" attributes = { "controller": get_controller_mock(), "name": "circuit_name", "uni_a": get_uni_mocked(is_valid=True), "uni_z": get_uni_mocked(is_valid=True) } evc1 = EVC(**attributes) evc2 = EVC(**attributes) attributes = { "controller": get_controller_mock(), "name": "circuit_name_2", "uni_a": get_uni_mocked(is_valid=True), "uni_z": get_uni_mocked(is_valid=True) } evc3 = EVC(**attributes) evc4 = EVC(**attributes) self.assertEqual(evc1 == evc2, True) self.assertEqual(evc1 == evc3, False) self.assertEqual(evc2 == evc3, False) self.assertEqual(evc3 == evc4, True)
def test_update_uni_a(self): """Test if raises and error when trying to update the uni_a.""" attributes = { "controller": get_controller_mock(), "name": "circuit_name", "uni_a": get_uni_mocked(is_valid=True), "uni_z": get_uni_mocked(is_valid=True) } update_dict = { "uni_a": get_uni_mocked(is_valid=True) } error_message = "uni_a can't be be updated." with self.assertRaises(ValueError) as handle_error: evc = EVC(**attributes) evc.update(**update_dict) self.assertEqual(str(handle_error.exception), error_message)
def setUp(self): """Execute steps before each tests. Set the server_name_url from kytos/of_core """ self.switch_v0x01 = get_switch_mock("00:00:00:00:00:00:00:01", 0x01) self.switch_v0x04 = get_switch_mock("00:00:00:00:00:00:00:02", 0x04) self.switch_v0x01.connection = get_connection_mock( 0x01, get_switch_mock("00:00:00:00:00:00:00:03")) self.switch_v0x04.connection = get_connection_mock( 0x04, get_switch_mock("00:00:00:00:00:00:00:04")) patch('kytos.core.helpers.run_on_thread', lambda x: x).start() # pylint: disable=import-outside-toplevel from napps.kytos.of_core.main import Main self.addCleanup(patch.stopall) self.napp = Main(get_controller_mock())
def setUp(self): """Execute steps before each tests. Set the server_name_url_url from kytos/mef_eline """ self.server_name_url = 'http://localhost:8181/api/kytos/mef_eline' # The decorator run_on_thread is patched, so methods that listen # for events do not run on threads while tested. # Decorators have to be patched before the methods that are # decorated with them are imported. patch('kytos.core.helpers.run_on_thread', lambda x: x).start() from napps.kytos.mef_eline.main import Main self.addCleanup(patch.stopall) self.napp = Main(get_controller_mock())
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=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 } evc = EVC(**attributes) evc.current_path = evc.backup_path 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) deploy_to_mocked.assert_called_once_with('primary_path', evc.primary_path) 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_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_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] 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.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 } evc = EVC(**attributes) evc.current_path = evc.primary_path 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=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.backup_path 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 in_vlan_a = 10 out_vlan_a = 20 in_vlan_z = 3 # 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, 'dl_vlan': in_vlan_a }, 'cookie': evc.get_cookie(), 'actions': [{ 'action_type': 'set_vlan', 'vlan_id': in_vlan_z }, { 'action_type': 'push_vlan', 'tag_type': 's' }, { 'action_type': 'set_vlan', 'vlan_id': out_vlan_a }, { 'action_type': 'output', 'port': interface_z.port_number }] } self.assertEqual(expected_flow_mod, flow_mod)
def test_new_circuit_with_run_time(self, validate_mock, scheduler_add_job_mock): """Test if add new circuit with run_time.""" scheduler_add_job_mock.return_value = True validate_mock.return_value = True time_fmt = "%Y-%m-%dT%H:%M:%S" date = datetime.datetime.now().strftime(time_fmt) circuit_scheduler = CircuitSchedule(action="remove", date=date) options = {"controller": get_controller_mock(), "name": 'my evc1', "uni_a": 'uni_a', "uni_z": 'uni_z', "circuit_scheduler": [circuit_scheduler] } evc = EVC(**options) self.scheduler.add(evc) expected_parameters = { "id": circuit_scheduler.id, "run_date": circuit_scheduler.date, } scheduler_add_job_mock.assert_called_once_with(evc.remove, 'date', **expected_parameters)
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) 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_primary_path(self): """Test test is using primary path.""" primary_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}) ] 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 } 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_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_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 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_deploy_to_case_1(self, log_mocked): """Test if the path is equal to current_path.""" primary_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}) ] 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 } 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 setUp(self): """Start NApp thread.""" self.napp = Main(get_controller_mock())