def run(TagNameList, ObjectList, CurrVal, Iteration, TagList, IgnoreEmptyTags): if CurrVal != '': hdl_list = [int(s) for s in CurrVal.split(',')] else: hdl_list = [] if len(TagNameList) < len(hdl_list): raise RuntimeError('Not enough tag names specified, expected at ' + 'least' + str(len(hdl_list)) + ' elements') hnd_reg = CHandleRegistry.Instance() # Before processing, remove any objects from tags for tag in TagNameList: tag_obj = tag_utils.get_tag_object(tag) # Clear anything the tag points to exist_list = tag_utils.get_tagged_objects([tag_obj]) for rem_obj in exist_list: rem_obj.RemoveObject(tag_obj, RelationType('UserTag')) for tag, hdl in zip(TagNameList, hdl_list): tag_obj = tag_utils.get_tag_object(tag) obj = hnd_reg.Find(hdl) # Is this an error if we are getting an invalid handle? if obj is None: continue # Add the object to the tag (not using util, since it operates on str) obj.AddObject(tag_obj, RelationType('UserTag')) return True
def test_generate_tagged_ports_empty_port_list(stc): project = CStcSystem.Instance().GetObject('Project') ctor = CScriptableCreator() left_tag = tag_utils.get_tag_object('Left_Port_Group') right_tag = tag_utils.get_tag_object('Right_Port_Group') ep_cfg = ctor.Create('ExposedConfig', project) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'LeftPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(left_tag, RelationType('ScriptableExposedProperty')) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'RightPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(right_tag, RelationType('ScriptableExposedProperty')) # The sample didn't have everything, so this unit test will take the # minimum needed input_dict = { "port_groups": [ { "prop_id": "LeftPortGroup", "name": "Left" }, { "prop_id": "RightPortGroup", "name": "Right" } ], } port_hnd_list, offline, err_str = RunCmd.generate_tagged_ports(input_dict) assert port_hnd_list == [] assert err_str == "Port group {} has empty port list"
def test_generate_tagged_ports_no_port_groups(stc): project = CStcSystem.Instance().GetObject('Project') ctor = CScriptableCreator() left_tag = tag_utils.get_tag_object('Left_Port_Group') right_tag = tag_utils.get_tag_object('Right_Port_Group') ep_cfg = ctor.Create('ExposedConfig', project) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'LeftPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(left_tag, RelationType('ScriptableExposedProperty')) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'RightPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(right_tag, RelationType('ScriptableExposedProperty')) # The sample didn't have everything, so this unit test will take the # minimum needed input_dict = { } port_hnd_list, offline, err_str = ConfigCmd.generate_tagged_ports(input_dict) assert port_hnd_list == [] assert err_str == "Input missing required port_groups section"
def test_get_tag_objects_blank(stc): fail_msg = '' try: tag_utils.get_tag_object('') except: exc_info = sys.exc_info() fail_list = traceback.format_exception_only(exc_info[0], exc_info[1]) fail_msg = fail_list[0] if len(fail_list) == 1 else '\n'.join(fail_list) if fail_msg == '': raise AssertionError('function did not fail as expected') if 'must not be blank' not in fail_msg: raise AssertionError('function failed with unexpected exception: "' + fail_msg + '"') try: tag_utils.get_tag_object_list(['non-blank', '']) except: exc_info = sys.exc_info() fail_list = traceback.format_exception_only(exc_info[0], exc_info[1]) fail_msg = fail_list[0] if len(fail_list) == 1 else '\n'.join(fail_list) if fail_msg == '': raise AssertionError('function did not fail as expected') if 'must not be blank' not in fail_msg: raise AssertionError('function failed with unexpected exception: "' + fail_msg + '"')
def test_run_tuple_empty(stc): ctor = CScriptableCreator() tag_utils.get_tag_object('Nothing') # Most of the parameters from the base class are ignored cmd = ctor.CreateCommand(CMD) cmd.SetCollection('TagNameList', ['Nothing', 'Nothing']) cmd.Set('ObjectOrder', 'SCALAR') cmd.Execute() # Pass 1 assert 0 == cmd.Get('Iteration') assert '' == cmd.Get('CurrVal') assert 'FAILED' == cmd.Get('PassFailState') cmd.MarkDelete()
def test_get_tag_object(stc): proj = CStcSystem.Instance().GetObject("Project") ctor = CScriptableCreator() tags = proj.GetObject('Tags') if tags is None: tags = ctor.Create('Tags', project) assert tags is not None exist_map = {obj.Get('Name'): obj for obj in tags.GetObjects('Tag')} # Create new tag = tag_utils.get_tag_object('Tag1') assert not isinstance(tag, list) assert tag.IsTypeOf('Tag') assert 'Tag1' == tag.Get('Name') assert 'Tag1' not in exist_map # Retrieve existing tag2 = tag_utils.get_tag_object('Tag1') assert tag.GetObjectHandle() == tag2.GetObjectHandle() assert 'Tag1' == tag2.Get('Name')
def test_run_scalar(stc): ctor = CScriptableCreator() proj = CStcSystem.Instance().GetObject('Project') # Set up tagged objects port = ctor.Create('Port', proj) for num in range(0, 4): with AutoCommand('DeviceCreateCommand') as cmd: cmd.Set('Port', port.GetObjectHandle()) cmd.Set('DeviceCount', 1) cmd.Set('CreateCount', 1) cmd.Set('DeviceType', 'EmulatedDevice') cmd.SetCollection('IfStack', ['Ipv4If', 'EthIIIf']) cmd.SetCollection('IfCount', [1, 1]) cmd.Execute() dev_list = proj.GetObjects('EmulatedDevice') assert 4 == len(dev_list) cmd = ctor.CreateCommand(CMD) curr_val = str(dev_list[0].GetObjectHandle()) cmd.SetCollection('TagNameList', ['Sample']) cmd.Set('CurrVal', curr_val) cmd.Set('Iteration', 1) cmd.Execute() sample_tag = tag_utils.get_tag_object('Sample') targ_list = sample_tag.GetObjects('Scriptable', RelationType('UserTag', True)) # Remove 'Tags' targ_list = [o.GetObjectHandle() for o in targ_list if not o.IsTypeOf('Tags')] assert 1 == len(targ_list) assert dev_list[0].GetObjectHandle() == targ_list[0] cmd.Reset() # Call it again, with another handle curr_val = str(dev_list[1].GetObjectHandle()) cmd.SetCollection('TagNameList', ['Sample']) cmd.Set('CurrVal', curr_val) cmd.Set('Iteration', 2) cmd.Execute() targ_list = sample_tag.GetObjects('Scriptable', RelationType('UserTag', True)) # Remove 'Tags' targ_list = [o.GetObjectHandle() for o in targ_list if not o.IsTypeOf('Tags')] assert 1 == len(targ_list) assert dev_list[1].GetObjectHandle() == targ_list[0] # Clean up cmd.MarkDelete()
def test_run_pass_in_json(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin test_run") stc_sys = CStcSystem.Instance() sequencer = stc_sys.GetObject("Sequencer") ctor = CScriptableCreator() common_data_path = stc_sys.GetApplicationCommonDataPath() # Create exposed properties for the ports project = stc_sys.GetObject('Project') left_tag = tag_utils.get_tag_object('Left_Port_Group') ep_cfg = ctor.Create('ExposedConfig', project) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'LeftPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(left_tag, RelationType('ScriptableExposedProperty')) meth_name = "RFC2544THROUGHPUT_SAMPLE_BASIC" test_name = "test_run" # Clean up the fake installed methodology (if it exists) if os.path.exists(os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR, meth_name)): meth_man_utils.methodology_rmdir(meth_name) # Create a fake installed methodology home_dir = meth_man_utils.get_methodology_home_dir() assert home_dir is not None meth_dir = meth_man_utils.methodology_mkdir(meth_name) assert meth_dir is not None test_dir = meth_man_utils.methodology_test_case_mkdir(meth_name, test_name) assert test_dir is not None # Add a fake sequence file seq_file = os.path.join(meth_dir, mgr_const.MM_SEQUENCER_FILE_NAME) f = open(seq_file, "w") f.write("<?xml version=\"1.0\" encoding=\"windows-1252\"?>") f.close() # Add a fake TXML file meta_file = os.path.join(meth_dir, mgr_const.MM_META_FILE_NAME) f = open(meta_file, "w") data = UnitTestUtils.gen_test_info_header("unit test meth disp name", meth_name, "unit test meth test case", "") data = data + UnitTestUtils.UTU_FOOTER f.write(data) f.close() # Initialize the methodology manager by calling update cmd = ctor.CreateCommand(PKG + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() # meth_man = meth_man_utils.get_meth_manager() # assert meth_man # test_meth_obj_list = meth_man.GetObjects("StmMethodology") # assert len(test_meth_obj_list) > 0 # test_meth = None # for test_meth_obj in test_meth_obj_list: # act_meth_key = test_meth_obj.Get("MethodologyKey") # plLogger.LogDebug("meth_name: " + test_meth_obj.Get("Name")) # plLogger.LogDebug("meth_key: " + test_meth_obj.Get("MethodologyKey")) # if act_meth_key == meth_name: # test_meth = test_meth_obj # break # Add MethodologyGroupCommand to the sequencer meth_group_cmd = ctor.Create(PKG + ".MethodologyGroupCommand", sequencer) sequencer.SetCollection("CommandList", [meth_group_cmd.GetObjectHandle()]) key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json == "" cmd = ctor.Create(PKG + ".RunMethodologyTestCommand", sequencer) RunCmd.get_this_cmd = MagicMock(return_value=cmd) RunCmd.load_config = MagicMock() # TODO: set it up so we don't have to mock this function RunCmd.set_active_test_case = MagicMock() # Call run with all empty # res = RunCmd.run("", "", "", "", False) # assert not res # assert 'MethodologyJson does not conform to the schema' in cmd.Get("Status") # assert cmd.Get("OutputTestCaseKey") == '' # cmd.Set("Status", '') # Call run with invalid meth key # res = RunCmd.run("", "", "blah", "", False) # assert not res # assert 'MethodologyJson does not conform to the schema' in cmd.Get("Status") # assert cmd.Get("OutputTestCaseKey") == '' # cmd.Set("Status", '') # Call run with empty json # res = RunCmd.run("", "", meth_name, "", False) # assert not res # assert 'MethodologyJson does not conform to the schema' in cmd.Get("Status") # assert cmd.Get("OutputTestCaseKey") == '' # cmd.Set("Status", '') # Call run with invalid json # res = RunCmd.run("", "", meth_name, "invalid json", False) # assert not res # assert 'MethodologyJson does not conform to the schema' in cmd.Get("Status") # assert cmd.Get("OutputTestCaseKey") == '' # cmd.Set("Status", '') # Call the run function with valid meth key and json res = RunCmd.run("", "", meth_name, get_sample_2544_json_basic(), False) assert res assert cmd.Get("Status") == '' assert cmd.Get("OutputTestCaseKey") == meth_name + '-1' # The KeyValueJson should be populated after running the command key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json != "" err_str, key_value_dict = json_utils.load_json(key_value_json) assert err_str == "" assert key_value_dict is not None assert len(key_value_dict.items()) == 1 assert key_value_dict["AddressStartValue"] == "1.1.1.1" # Clean up the fake installed methodology if os.path.exists(os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR, meth_name)): meth_man_utils.methodology_rmdir(meth_name)
def test_run(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin test_run") stc_sys = CStcSystem.Instance() sequencer = stc_sys.GetObject("Sequencer") ctor = CScriptableCreator() common_data_path = stc_sys.GetApplicationCommonDataPath() # Create exposed properties for the ports project = stc_sys.GetObject('Project') left_tag = tag_utils.get_tag_object('Left_Port_Group') right_tag = tag_utils.get_tag_object('Right_Port_Group') ep_cfg = ctor.Create('ExposedConfig', project) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'LeftPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(left_tag, RelationType('ScriptableExposedProperty')) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'RightPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(right_tag, RelationType('ScriptableExposedProperty')) meth_name = "test_RunMethodologyTestCommand_test_run" test_name = "test_run" # Clean up the fake installed methodology (if it exists) if os.path.exists(os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR, meth_name)): meth_man_utils.methodology_rmdir(meth_name) # Create a fake installed methodology home_dir = meth_man_utils.get_methodology_home_dir() assert home_dir is not None meth_dir = meth_man_utils.methodology_mkdir(meth_name) assert meth_dir is not None test_dir = meth_man_utils.methodology_test_case_mkdir(meth_name, test_name) assert test_dir is not None cmd = ctor.Create(PKG + ".RunMethodologyTestCommand", sequencer) RunCmd.get_this_cmd = MagicMock(return_value=cmd) RunCmd.load_config = MagicMock() # TODO: set it up so we don't have to mock this function RunCmd.set_active_test_case = MagicMock() # Create a valid JSON file json_content = get_sample_2544_json() meta_json_file = os.path.join(test_dir, mgr_const.MM_META_JSON_FILE_NAME) f = open(meta_json_file, "w") f.write(json_content) f.close() meth_man = stc_sys.GetObject("StmMethodologyManager") if meth_man is None: meth_man = ctor.Create("StmMethodologyManager", stc_sys) assert meth_man test_meth = ctor.Create("StmMethodology", meth_man) test_meth.Set("MethodologyKey", meth_name) test_case = ctor.Create("StmTestCase", test_meth) assert test_case is not None assert test_case.IsTypeOf("StmTestCase") test_case.Set("Path", test_dir) test_case.Set("TestCaseKey", test_name) # Add MethodologyGroupCommand to the sequencer meth_group_cmd = ctor.Create(PKG + ".MethodologyGroupCommand", sequencer) sequencer.SetCollection("CommandList", [meth_group_cmd.GetObjectHandle()]) key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json == "" # Call the run function with invalid StmTestCase handle res = RunCmd.run("", test_meth.GetObjectHandle(), "", "", False) assert not res assert 'Was unable to find StmTestCase with handle' in cmd.Get("Status") cmd.Set("Status", '') # Call the run function with missing proc function script file res = RunCmd.run("", test_case.GetObjectHandle(), "", "", False) assert not res assert cmd.Get("Status") == 'Failed to find script: RunMethodologyTestCommandTestScript.py' cmd.Set("Status", '') # Create the proc function script file err_str, meta = json_utils.load_json(json_content) assert err_str == "" script_filename = meta["processing_functions"][0]["script_filename"] script_full_path = write_testscript(script_filename) assert script_full_path is not None # Call the run function with valid StmTestCaseHandle res = RunCmd.run("", test_case.GetObjectHandle(), "", "", False) assert res assert cmd.Get("Status") == '' # The KeyValueJson should be populated after running the command key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json != "" err_str, key_value_dict = json_utils.load_json(key_value_json) assert err_str == "" assert key_value_dict is not None assert len(key_value_dict.items()) == 8 assert key_value_dict["CommandAddressStartValue"] == "198.18.1.2" assert key_value_dict["CommandAddressStepValue"] == "0.0.1.0" assert key_value_dict["TrafficDuration"] == "60" vlist = key_value_dict["ObjectIteratorCommand.ValueList"] assert type(vlist) is list sitems = set(vlist) & set(["64", "128", "256", "512", "1024", "1280", "1518"]) assert len(sitems) == 7 assert key_value_dict["cmd1.bgp.count"] == "3" # Clear out KeyValueJson in the meth group command meth_group_cmd.Set("KeyValueJson", "") key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json == "" # Call the run function with invalid test case key res = RunCmd.run("InvalidTestCaseKey", 0, "", "", False) assert not res assert cmd.Get("Status") == 'Test case with key InvalidTestCaseKey not found' cmd.Set("Status", '') # Call the run function with valid test case key res = RunCmd.run(test_name, 0, "", "", False) assert res assert cmd.Get("Status") == '' # The KeyValueJson should be populated after running the command key_value_json = meth_group_cmd.Get("KeyValueJson") assert key_value_json != "" err_str, key_value_dict = json_utils.load_json(key_value_json) assert err_str == "" assert key_value_dict is not None assert len(key_value_dict.items()) == 8 assert remove_testscript(script_full_path) # Clean up the fake installed methodology if os.path.exists(os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR, meth_name)): meth_man_utils.methodology_rmdir(meth_name)
def test_generate_tagged_ports(stc): project = CStcSystem.Instance().GetObject('Project') ctor = CScriptableCreator() left_tag = tag_utils.get_tag_object('Left_Port_Group') right_tag = tag_utils.get_tag_object('Right_Port_Group') ep_cfg = ctor.Create('ExposedConfig', project) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'LeftPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(left_tag, RelationType('ScriptableExposedProperty')) ep = ctor.Create('ExposedProperty', ep_cfg) ep.Set('EPNameId', 'RightPortGroup') ep.Set('EPClassId', 'tag') ep.Set('EPPropertyId', 'scriptable.name') ep.AddObject(right_tag, RelationType('ScriptableExposedProperty')) # The sample didn't have everything, so this unit test will take the # minimum needed input_dict_string = '''{ "port_groups": [ { "prop_id": "LeftPortGroup", "name": "Left", "bring_online": true, "ports": [ { "location": "10.10.10.1/1/1" } ] }, { "prop_id": "RightPortGroup", "name": "Right", "ports": [ { "location": "10.10.10.2/1/1" } ] } ] }''' err_str, input_dict = json_utils.load_json(input_dict_string) assert err_str == "" port_hnd_list, offline, err_str = RunCmd.generate_tagged_ports(input_dict) assert 2 == len(port_hnd_list) assert False is offline assert err_str == "" hnd_reg = CHandleRegistry.Instance() port_list = [hnd_reg.Find(hnd) for hnd in port_hnd_list] tag0 = port_list[0].GetObject('Tag', RelationType('UserTag')) tag1 = port_list[1].GetObject('Tag', RelationType('UserTag')) assert left_tag.GetObjectHandle() == tag0.GetObjectHandle() assert port_list[0].Get('Name').startswith('Left 1') assert port_list[0].Get('Location') == '//10.10.10.1/1/1' assert right_tag.GetObjectHandle() == tag1.GetObjectHandle() assert port_list[1].Get('Name').startswith('Right 1') assert port_list[1].Get('Location') == '//10.10.10.2/1/1' # Test the bring_online parameter input_dict_string = '''{ "port_groups": [ { "prop_id": "LeftPortGroup", "name": "Left", "bring_online": false, "ports": [ { "location": "10.10.10.1/1/1" } ] }, { "prop_id": "RightPortGroup", "name": "Right", "bring_online": true, "ports": [ { "location": "10.10.10.2/1/1" } ] } ] }''' err_str, input_dict = json_utils.load_json(input_dict_string) assert err_str == "" port_hnd_list, offline, err_str = RunCmd.generate_tagged_ports(input_dict) assert 2 == len(port_hnd_list) assert True is offline assert err_str == ""
def process_wizard_args(tmpl_cfg, wiz_list): ''' Inputs: Template config and list of wizard dictionaries containing targetTagList, srcObjectTagName, createdRoutesTagName, commandName ''' plLogger = PLLogger.GetLogger('methodology') this_cmd = get_this_cmd() for wiz in wiz_list: targ_tag_list = wiz.get('targetTagList') src_tag = wiz.get('srcObjectTagName') route_tag_name = wiz.get('createdRoutesTagName') command_name = wiz.get('commandName') # FIXME: It seems curious that the bllWizardExpand section has a # target tag list, when the command itself has the same list as a # input property -- evaluate whether this can be eliminated if not targ_tag_list: err = "No target tag list given" plLogger.LogError(err) this_cmd.Set('Status', err) return False if not src_tag: err = "No source object tag given" plLogger.LogError(err) this_cmd.Set('Status', err) return False if not command_name: err = "Command name not specified" plLogger.LogError(err) this_cmd.Set('Status', err) return False rtr_list = tag_utils.get_tagged_objects_from_string_names(targ_tag_list) # Remove duplicates by using an ordered dictionary rtr_list = dm_utils.remove_dup_scriptable(rtr_list) if len(rtr_list) == 0: err = "targetTagList results in an empty list" plLogger.LogError(err) this_cmd.Set('Status', err) return False pf_state, status = 'FAILED', '' with AutoCommand(PKG + '.ExpandTemplateCommand') as cmd: cmd.SetCollection('StmTemplateConfigList', [tmpl_cfg.GetObjectHandle()]) cmd.SetCollection('SrcTagList', [src_tag]) cmd.Execute() pf_state = cmd.Get('PassFailState') status = cmd.Get('Status') if pf_state == 'FAILED': err = '{}.ExpandTemplateCommand failed: {}' \ .format(PKG, status) plLogger.LogError(err) this_cmd.Set('Status', err) return False # Call the wizard once the configuration is loaded cfg_obj_list = tag_utils.get_tagged_objects_from_string_names([src_tag]) if not cfg_obj_list: err = 'Failed to load expected configuration object for {}' \ .format(tmpl_cfg.Get('Name')) plLogger.LogError(err) this_cmd.Set('Status', err) return False if len(cfg_obj_list) > 1: err = 'More than one configuration objects loaded from {}' \ .format(tmpl_cfg.Get('Name')) plLogger.LogInfo(err) # We check the object list just to prevent bad input. The target # command operates on the tag only, so we don't need to manipulate the # objects beyond getting the count pf_state, status = 'FAILED', '' tag_created = False if not route_tag_name: route_tag_name = 'Tmp Imported Routes' tag_created = True with AutoCommand(command_name) as cmd: # Set the parameters depending on the command used if 'Import' in command_name: cmd.SetCollection('RouterTagList', targ_tag_list) cmd.Set('BgpImportParamsTagName', src_tag) cmd.Set('CreatedRoutesTagName', route_tag_name) elif 'Prefix' in command_name: cmd.SetCollection('RouterTagList', targ_tag_list) cmd.Set('SrcObjectTagName', src_tag) cmd.Set('CreatedRoutesTagName', route_tag_name) cmd.Execute() pf_state = cmd.Get('PassFailState') status = cmd.Get('Status') if pf_state == 'FAILED': err = '{} failed: {}'.format(command_name, status) plLogger.LogError(err) this_cmd.Set('Status', err) return False # After a successful run, we need to associate the newly-created # routes to the template with the GeneratedObject relation added_route_list = \ tag_utils.get_tagged_objects_from_string_names([route_tag_name]) for route in added_route_list: tmpl_cfg.AddObject(route, RelationType('GeneratedObject')) # If we created a temporary tag, delete it here if tag_created: tag_obj = tag_utils.get_tag_object(route_tag_name) tag_obj.MarkDelete() return True
def process_route_args(tmpl_cfg, routers_dict): ''' Purpose: Calls the ExpandTemplateCommand for each protocol in the configuration Inputs: Template config and component section from the templatemix ''' plLogger = PLLogger.GetLogger("methodology") this_cmd = get_this_cmd() root = etree.fromstring(tmpl_cfg.Get('TemplateXml')) # For each kind of RouterConfig, check this StmTemplateConfig's # XML tree for that classname. for router_type in routers_dict: # Remove serializationBase from the XML serial_ele_list = root.findall('.//*[@serializationBase="true"]') for ele in serial_ele_list: if 'serializationBase' in ele.attrib: ele.attrib.pop('serializationBase') ele_list = root.findall(".//" + router_type) if not ele_list: continue # We found, for instance, a BgpRouterConfig both in the # template XML, and in StmProtocolMix's objects, so we # expand this StmTemplateConfig onto all those objects if len(ele_list) != 1: err = "More than one {} found. That's weird." \ .format(router_type) plLogger.LogError(err) this_cmd.Set('Status', err) return False router_ele = ele_list[0] # Mark all children with serializationBase for child in router_ele: plLogger.LogInfo("process element: " + str(child)) if child.tag == "Relation": # Except for Relation elements continue # Check for Ipv4NetworkBlocks or Ipv6NetworkBlocks ipv4_net_block = child.find(".//Ipv4NetworkBlock") ipv6_net_block = child.find(".//Ipv6NetworkBlock") if (ipv4_net_block is not None and len(ipv4_net_block)) or \ (ipv6_net_block is not None and len(ipv6_net_block)): child.attrib["serializationBase"] = "true" else: plLogger.LogWarn("Skipping object of type " + child.tag) # Make temporary tags for this instance of ExpandRouteMixCommand tag_obj = tag_utils.get_tag_object(TEMP_TRG_TAG) # Tag all routerConfigs in the dictionary of this type # with a temporary target tag, since ExpandTemplateCommand # needs that for router in routers_dict[router_type]: tag_utils.add_tag_to_object(router, TEMP_TRG_TAG) tmpl_cfg.Set("TemplateXml", etree.tostring(root)) pf_state, status = 'FAILED', '' with AutoCommand(PKG + '.ExpandTemplateCommand') as cmd: cmd.SetCollection('StmTemplateConfigList', [tmpl_cfg.GetObjectHandle()]) cmd.SetCollection("TargetTagList", [TEMP_TRG_TAG]) cmd.Execute() pf_state = cmd.Get('PassFailState') status = cmd.Get('Status') if pf_state == 'FAILED': err = '{}.ExpandTemplateCommand failed: {}' \ .format(PKG, status) plLogger.LogError(err) this_cmd.Set('Status', err) return False # After expand of routes is done, remove the tag from the target # router objects tag_obj.MarkDelete() return True
def test_run_tuple_mismatch(stc): ctor = CScriptableCreator() proj = CStcSystem.Instance().GetObject('Project') # Set up tagged objects port = ctor.Create('Port', proj) for num in range(0, 4): with AutoCommand('DeviceCreateCommand') as cmd: cmd.Set('Port', port.GetObjectHandle()) cmd.Set('DeviceCount', 1) cmd.Set('CreateCount', 1) cmd.Set('DeviceType', 'EmulatedDevice') cmd.SetCollection('IfStack', ['Ipv4If', 'EthIIIf']) cmd.SetCollection('IfCount', [1, 1]) cmd.Execute() dev_list = proj.GetObjects('EmulatedDevice') assert 4 == len(dev_list) cmd = ctor.CreateCommand(CMD) curr_val = str(dev_list[0].GetObjectHandle()) + ',' + \ str(dev_list[2].GetObjectHandle()) # Only one tag value given cmd.SetCollection('TagNameList', ['Sample']) cmd.Set('CurrVal', curr_val) try: cmd.Execute() except: exc_info = sys.exc_info() fail_list = traceback.format_exception_only(*exc_info[0:2]) fail_msg = fail_list[0] if len(fail_list) == 1 else '\n'.join(fail_list) finally: cmd.MarkDelete() if fail_msg == '': raise AssertionError('Command did not fail as expected') if 'Not enough tag names' not in fail_msg: raise AssertionError('Command failed with unexpected exception: "' + fail_msg + '"') cmd.Reset() curr_val = str(dev_list[0].GetObjectHandle()) # Only one tag value given cmd.SetCollection('TagNameList', ['Sample', 'Dest']) cmd.Set('CurrVal', curr_val) # Should be ok if we have more tags than values cmd.Execute() sample_tag = tag_utils.get_tag_object('Sample') dest_tag = tag_utils.get_tag_object('Dest') targ_list = sample_tag.GetObjects('Scriptable', RelationType('UserTag', True)) # Remove 'Tags' targ_list = [o.GetObjectHandle() for o in targ_list if not o.IsTypeOf('Tags')] targ_list = sample_tag.GetObjects('Scriptable', RelationType('UserTag', True)) # Remove 'Tags' targ_list = [o.GetObjectHandle() for o in targ_list if not o.IsTypeOf('Tags')] targ2_list = dest_tag.GetObjects('Scriptable', RelationType('UserTag', True)) # Remove 'Tags' targ2_list = [o.GetObjectHandle() for o in targ2_list if not o.IsTypeOf('Tags')] # Verify assert 1 == len(targ_list) assert dev_list[0].GetObjectHandle() == targ_list[0] assert 0 == len(targ2_list)