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)