def test_cmd_with_res_fmwk(stc): ctor = CScriptableCreator() sequencer = CStcSystem.Instance().GetObject("Sequencer") # Set up an iteration group group_cmd = ctor.Create(PKG + ".IterationGroupCommand", sequencer) assert group_cmd while_cmd = ctor.Create("SequencerWhileCommand", group_cmd) assert while_cmd iter_cmd = ctor.Create(PKG + ".ObjectIteratorCommand", while_cmd) valid_cmd = ctor.Create(PKG + ".IteratorValidateCommand", while_cmd) while_cmd.Set("ExpressionCommand", iter_cmd.GetObjectHandle()) while_cmd.SetCollection("CommandList", [valid_cmd.GetObjectHandle()]) group_cmd.SetCollection("CommandList", [while_cmd.GetObjectHandle()]) sequencer.SetCollection("CommandList", [group_cmd.GetObjectHandle()]) # Setup the methodology manager and the active test case meth_mgr = meth_mgr_utils.get_meth_manager() assert meth_mgr is not None methodology = ctor.Create("StmMethodology", meth_mgr) test_case = ctor.Create("StmTestCase", methodology) meth_mgr_utils.set_active_test_case(test_case) test_case_res = meth_mgr_utils.get_stm_test_result() assert test_case_res is not None # Mock get_this_cmd IteratorValidateCommand.get_this_cmd = MagicMock(return_value=valid_cmd) # Set up the results framework (passing iteration) RI.create_test() RI.start_test() fs = 128 fs_iter_id = 1 fs_iter_hnd = iter_cmd.GetObjectHandle() RI.set_iterator_current_value(fs_iter_hnd, "FrameSize", fs, fs_iter_id) RI.add_provider_result(test_utils.dummy_verify_result_passed) RI.complete_iteration() # Call the different parts of the command and verify the results res = IteratorValidateCommand.run(fs_iter_id) assert res is True assert valid_cmd.Get("Verdict") is True # Failed iteration RI.set_iterator_current_value(fs_iter_hnd, "FrameSize", fs + 128, fs_iter_id + 1) RI.add_provider_result(test_utils.dummy_verify_result_failed) RI.complete_iteration() res = IteratorValidateCommand.run(fs_iter_id + 1) assert res is True assert valid_cmd.Get("Verdict") is False
def get_stm_test_result(): """ Return StmTestResult object if exist else return None. """ logger.debug('get_stm_test_result started.') result_parent = meth_man_utils.get_meth_manager() active_test = meth_man_utils.get_active_test_case() if active_test is not None: result_parent = active_test test_result = result_parent.GetObject('StmTestResult') logger.debug('get_stm_test_result completed.') return test_result
def test_param_a_to_script(stc): stc_sys = CStcSystem.Instance() project = stc_sys.GetObject('Project') sequencer = stc_sys.GetObject("Sequencer") ctor = CScriptableCreator() pkg = "spirent.methodology" tags = project.GetObject('Tags') tagA = ctor.Create("tag", tags) tagA.Set("Name", "tagA") cmd = ctor.Create(pkg + ".RunPyScriptCommand", sequencer) RunPyScriptCommand.get_this_cmd = MagicMock(return_value=cmd) cmd2 = ctor.Create(pkg + ".LoadTemplateCommand", sequencer) cmd2.AddObject(tagA, RelationType("UserTag")) script_folder = mmutils.get_scripts_home_dir() filename = os.path.join(script_folder, "unit_test_file_param_a_to_script.py") try: if not os.path.exists(script_folder): os.makedirs(script_folder) with open(filename, "w") as f: f.write(unit_test_file_param_a_to_script()) RunPyScriptCommand.run("unit_test_file_param_a_to_script", "run", "tagA", {'a': 4}) assert cmd2.Get("CopiesPerParent") == 4 finally: remove_files(filename) return
def hold_test_error_returned(stc): stc_sys = CStcSystem.Instance() project = stc_sys.GetObject('Project') sequencer = stc_sys.GetObject("Sequencer") ctor = CScriptableCreator() pkg = "spirent.methodology" tags = project.GetObject('Tags') tagA = ctor.Create("tag", tags) tagA.Set("Name", "tagA") cmd = ctor.Create(pkg + ".RunPyScriptCommand", sequencer) RunPyScriptCommand.get_this_cmd = MagicMock(return_value=cmd) script_folder = mmutils.get_scripts_home_dir() filename = os.path.join(script_folder, "unit_test_file_error_returned.py") try: if not os.path.exists(script_folder): os.makedirs(script_folder) with open(filename, "w") as f: f.write(unit_test_file_error_returned()) rc = RunPyScriptCommand.run("unit_test_file_error_returned", "errorout", "tagA", {}) assert rc is False assert cmd.Get("ErrorMsg") != "" finally: remove_files(filename) return
def find_template_file(file_path): if not os.path.isabs(file_path): abs_file_name = mmutils.find_template_across_common_paths(file_path) if abs_file_name != '': file_path = abs_file_name if os.path.isfile(file_path): return file_path, True else: return file_path, False
def import_rules_file(self, rules_file): if not os.path.isfile(rules_file): found_file = mmutils.find_file_across_common_paths(rules_file) if found_file == '': return 'Unable to find rules file:' + rules_file rules_file = found_file with open(rules_file, 'r') as f: file_content = f.read() return self.import_content(file_content)
def reset(): """Create StmTestResult object if does not exist. reset object if exist. StmTestResult object should be created under active test. If active test does not exist then under methodology manager. """ logger.debug('Reset result objects.') result_parent = meth_man_utils.get_meth_manager() active_test = meth_man_utils.get_active_test_case() if active_test is not None: logger.debug('Active test is result parent.') result_parent = active_test test_result = result_parent.GetObject('StmTestResult') if test_result is None: ctor = CScriptableCreator() test_result = ctor.Create("StmTestResult", result_parent) else: reset_stm_test_result(test_result) logger.debug('Reset result objects done.') return test_result
def run(): plLogger = get_logger() plLogger.LogDebug("begin.run") meth_mgr = mm_utils.get_meth_manager() test_meth_list = meth_mgr.GetObjects("StmMethodology") meta_jsons = get_meta_json(test_meth_list) this_cmd = get_this_cmd() this_cmd.Set("MethodologyList", meta_jsons) plLogger.LogDebug("end.run") return True
def load_xml_from_file(file_path): plLogger = PLLogger.GetLogger('methodology') xml_str = None if not os.path.isabs(file_path): full_path = mm_utils.find_template_across_common_paths(file_path) if full_path != '': file_path = full_path if os.path.isfile(file_path): with open(file_path, "r") as f: xml_str = f.read() else: plLogger.LogError("ERROR: Failed to find file " + file_path) return None return xml_str
def load_xmlroot_from_file(filename): # FIXME: This needs to move into an XML util file... plLogger = PLLogger.GetLogger("methodology") plLogger.LogDebug("begin.load_xmlroot_from_file.MethodologyGroupCommand") file_path = filename if not os.path.isabs(file_path): abs_file_name = mmutils.find_template_across_common_paths(file_path) if abs_file_name != '': file_path = abs_file_name if not os.path.isfile(file_path): plLogger.LogError("ERROR: Failed to find file '" + filename + "'") return None # return etree.parse(file_path) with open(file_path) as f: return etree.fromstring(f.read())
def test_create_stm_get_stm(stc, resource_cleanup): mm = meth_man_utils.get_meth_manager() assert mm is not None assert result_obj.get_stm_test_result() is None stm_result = mm.GetObject('StmTestResult') assert stm_result is None stm_result = result_obj.create_stm_test_result_under_mm() assert stm_result is not None stm_mm = mm.GetObject('StmTestResult') assert stm_result.GetObjectHandle() == stm_mm.GetObjectHandle() stm3 = result_obj.get_stm_test_result() assert stm3 is not None assert stm_result.GetObjectHandle() == stm3.GetObjectHandle() # check leaf iterator is none assert iterator_utils.get_leaf_iterator() is None # check StmTestResult is active result stm4 = iterator_utils.get_active_result_object() assert stm4 is not None assert stm_result.GetObjectHandle() == stm4.GetObjectHandle()
def test_validate_missing_method(): stc_sys = CStcSystem.Instance() sequencer = stc_sys.GetObject("Sequencer") ctor = CScriptableCreator() pkg = "spirent.methodology" cmd = ctor.Create(pkg + ".RunPyScriptCommand", sequencer) RunPyScriptCommand.get_this_cmd = MagicMock(return_value=cmd) script_folder = mmutils.get_scripts_home_dir() filename = os.path.join(script_folder, "unit_test_file_valid_script.py") try: if not os.path.exists(script_folder): os.makedirs(script_folder) with open(filename, "w") as f: f.write(unit_test_file_valid_script()) err = RunPyScriptCommand.validate("unit_test_file_valid_script", "", "tagA", "") assert err != "" finally: remove_files(filename) return
def find_config_path(file_name): stc_sys = CStcSystem.Instance() if os.path.isabs(file_name): if os.path.isfile(file_name): return file_name else: return None path_list = [] methodology = None test_case = meth_man_utils.get_active_test_case() if test_case: methodology = test_case.GetParent() path_list.append(test_case.Get('Path')) if methodology: path_list.append(methodology.Get('Path')) path_list.append(stc_sys.GetApplicationCommonDataPath()) for path in path_list: path = os.path.normpath(path) abs_path = os.path.join(path, file_name) if os.path.isfile(abs_path): return abs_path return None
def validate(TestCaseKey, StmTestCase, MethodologyKey, MethodologyJson, EnableResourceCheck): plLogger = PLLogger.GetLogger("methodology") plLogger.LogDebug("begin.validate.RunMethodologyTestCommand.") if TestCaseKey: # Check if test case key exists in installed methodologies test_case_handle, err_str = mm_utils.get_test_case_from_key(TestCaseKey) return err_str elif StmTestCase: hnd_reg = CHandleRegistry.Instance() test_case = hnd_reg.Find(StmTestCase) if test_case is None or not test_case.IsTypeOf("StmTestCase"): plLogger.LogError("Was unable to find StmTestCase with handle " + str(StmTestCase) + " in the system.") return "Could not find StmTestCase" else: # Must specify a key and json if not MethodologyKey or not MethodologyJson: return "Must specify a TestCaseKey, StmTestCase or MethodologyKey and MethodologyJson" # Validate against the schema this_cmd = get_this_cmd() res = json_utils.validate_json(MethodologyJson, this_cmd.Get("InputJsonSchema")) if res != "": return "Methodology JSON is invalid or does not conform to the schema: " + res # Load the json if it passes schema validation err_str, meth_json = json_utils.load_json(MethodologyJson) if err_str != "": return err_str # Check the MethodologyKey matches the meth key in the json if MethodologyKey != meth_json["methodology_key"]: return "Methodology Key does not match the methodology_key in the JSON" plLogger.LogDebug("end.validate.RunMethodologyTestCommand") return ""
def run(RouterTagList, BgpImportParamsTagName, CreatedRoutesTagName): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo(" Run BgpImportRoutesCommand") this_cmd = get_this_cmd() if not BgpImportParamsTagName: return "Invalid BgpImportParamsTagName passed in" router_obj_list = tag_utils.get_tagged_objects_from_string_names(RouterTagList) # Turn into handles router_list = [] for router_obj in router_obj_list: if router_obj.IsTypeOf('EmulatedDevice'): router_list.append(router_obj) elif routerObj.IsTypeOf('RouterConfig'): router_list.append(router_obj.GetParent().GetObjectHandle()) if not router_list: this_cmd.Set('Status', "RouterTagList does not point to any routers") return False param_obj_list = \ tag_utils.get_tagged_objects_from_string_names([BgpImportParamsTagName]) route_list = [] for param_obj in param_obj_list: # Remove any existing parameter list relations exist_list = param_obj.GetObjects('Scriptable', RelationType('SelectedRouterRelation')) for exist in exist_list: param_obj.RemoveObject(exist, RelationType('SelectedRouterRelation')) for router in router_list: param_obj.AddObject(router, RelationType('SelectedRouterRelation')) router_hdl_list = [r.GetObjectHandle() for r in router_list] # Create the BgpImportRouteTableCommand with AutoCommand('BgpImportRouteTableCommand') as cmd: cmd.Set("ImportParams", param_obj.GetObjectHandle()) # Ensure BLL command gets an absolute path abs_path = \ mm_utils.find_file_across_common_paths(param_obj.Get("FileName"), search_templates=True) if len(abs_path): param_obj.Set("FileName", abs_path) cmd.SetCollection("RouterList", router_hdl_list) cmd.Set("DeleteRoutes", "NO") cmd.Execute() cmd_state = cmd.Get('State') cmd_status = cmd.Get('Status') if cmd_state != 'COMPLETED': this_cmd.Set('Status', cmd_status) return False route_list = param_obj.GetObjects('BgpRouteConfig', RelationType('WizardGenerated')) if not route_list: this_cmd.Set('Status', 'Failed to generate any ' 'route objects for {}'.format(param_obj.Get('Name'))) return False tag_wizgenerated_as_created(param_obj, CreatedRoutesTagName) return True
def create_stm_test_result_under_mm(): logger.debug('Create StmTestResult object') result_parent = meth_man_utils.get_meth_manager() ctor = CScriptableCreator() test_result = ctor.Create("StmTestResult", result_parent) return test_result
def get_script_path(script_name): abs_path = mm_utils.find_script_across_common_paths(script_name + ".py") if abs_path == "": return "" return os.path.split(abs_path)[0]
def set_active_test_case(test_case): mm_utils.set_active_test_case(test_case) return
except Exception, e: err_str = str(e) result = cmd.Get("PassFailState") TestCaseKey = cmd.Get("TestCaseKey") cmd.MarkDelete() # Verify create command passed if err_str or result is None or result != "PASSED": err_str = "Failed to create methodology test case. " + err_str plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False if TestCaseKey: # Get test case from installed methodologies StmTestCase, err_str = mm_utils.get_test_case_from_key(TestCaseKey) if err_str: plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False # Get the StmTestCase object test_case = hnd_reg.Find(StmTestCase) if test_case is None or not test_case.IsTypeOf("StmTestCase"): err_str = "Was unable to find StmTestCase with handle " + str(StmTestCase) + " in the system." plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False # Get the StmMethodology so we can get the meth key stm_meth = test_case.GetObject("StmMethodology", RelationType("ParentChild", 1))
def run(StmTestCase, EnableTieCheck, EnableLoadConfig): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug('begin.run.RunStmTestCaseCommand') stc_sys = CStcSystem.Instance() hnd_reg = CHandleRegistry.Instance() test_case = hnd_reg.Find(StmTestCase) if test_case is None or not test_case.IsTypeOf('StmTestCase'): plLogger.LogError('Was unable to find StmTestCase with handle ' + str(StmTestCase) + ' in the system.') return False txml_path = os.path.join(test_case.Get('Path'), mgr_const.MM_META_FILE_NAME) plLogger.LogDebug('txml_path: ' + str(txml_path)) plLogger.LogDebug('stm_test_case: ' + test_case.Get('Name')) txml_root = get_txml_file_root(txml_path) if txml_root is None: plLogger.LogError('Could not parse TXML') return False # Parse the TXML for the keys and values key_val_dict, gui_key_val_dict = parse_txml_keys_values(txml_root) # Parse the TXML for the processing functions proc_func_dict = parse_txml_proc_funcs(txml_root) # Run the TXML processing functions res = run_txml_proc_funcs(proc_func_dict, key_val_dict, gui_key_val_dict) if not res: plLogger.LogError('Failed to run TXML processing functions!') return False # Parse the TXML processing dictionaries input_dict_list = get_txml_proc_dicts(txml_root) # Parse json dictionaries and run processing functions res = run_txml_proc_util(input_dict_list, key_val_dict, gui_key_val_dict) if not res: plLogger.LogError('Failed to run TXML processing function utilities!') return False port_group_dict = parse_txml_port_groups(txml_root) port_group_list = build_port_group_list(port_group_dict) plLogger.LogDebug('key_val_dict (json): ' + json.dumps(key_val_dict)) plLogger.LogDebug('port_group_list: ' + str(port_group_list)) # Remove the gui-only keys from key_val_dict for key in gui_key_val_dict.keys(): if key in key_val_dict.keys(): key_val_dict.pop(key) plLogger.LogDebug("key_val_dict without gui only keys (json): " + json.dumps(key_val_dict)) # Create the ports (they will be tagged appropriately)... ports, offline_detected = create_and_tag_ports(port_group_list) if EnableTieCheck and not offline_detected: estimationUtils = EstimationUtils(test_case) output_json = estimationUtils.get_estimates_json() plLogger.LogDebug('output_json: ' + output_json) tie_pkg = 'spirent.testintel' result = None verdict = [] with AutoCommand(tie_pkg + '.ScalingValidatePortsCommand') as tie_cmd: tie_cmd.Set('Profile', output_json) try: tie_cmd.Execute() except: pass result = tie_cmd.Get('PassFailState') try: verdict = json.loads(tie_cmd.Get('Verdict')) except: pass plLogger.LogInfo('Validation Verdict: {}'.format(verdict)) if result is None or result != 'PASSED': if result is None: plLogger.LogError('ERROR: Unable to create an instance of ' + tiepkg + '.ScalingValidatePortsCommand.') else: fail_list = [] for ent in verdict: if 'portLocations' not in ent: continue for loc in ent['portLocations']: if not loc['confidence']: out_fmt = 'Port {} can not run test: {}' out = out_fmt.format(loc['location'], loc['reason']) fail_list.append(out) elif loc['confidence'] < 100.0: out_fmt = 'Port {} may run with {}% confidence, ' + \ 'disable pre-run resource validation check ' + \ 'to proceed: {}' out = out_fmt.format(loc['location'], loc['confidence'], loc['reason']) fail_list.append(out) this_cmd = hnd_reg.Find(__commandHandle__) this_cmd.Set('Status', '\n'.join(fail_list)) # Common exit point after setting failure return False # If true, the caller hasn't already loaded the config, so do it on their behalf if EnableLoadConfig: with AutoCommand('LoadFromXml') as load_cmd: load_cmd.Set('FileName', os.path.join(test_case.Get('Path'), mgr_const.MM_SEQUENCER_FILE_NAME)) load_cmd.Execute() # Set the active test case mm_utils.set_active_test_case(test_case) # Configure the MethodologyGroupCommand sequencer = stc_sys.GetObject('Sequencer') cmd_list = sequencer.GetCollection('CommandList') for cmd_hnd in cmd_list: cmd = hnd_reg.Find(cmd_hnd) if cmd is None: continue if cmd.IsTypeOf("spirent.methodology.manager.MethodologyGroupCommand"): cmd.Set("KeyValueJson", json.dumps(key_val_dict)) break # If any of the ports were offline ports, then assume a test config # that isn't to connect to chassis (e.g., a unit test). if not offline_detected: attach_ports(ports) plLogger.LogDebug('end.run.RunStmTestCaseCommand') return True
def script_filename_path(ScriptFilename): file_path = assumed_filename(ScriptFilename) + ".py" abs_file_name = mmutils.find_script_across_common_paths(file_path) if abs_file_name != '': return os.path.split(abs_file_name)[0] return ""
def get_script_path(script_name): abs_path = mm_utils.find_script_across_common_paths(script_name + '.py') if abs_path == '': return '' return os.path.split(abs_path)[0]