def run(StmMethodology): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("DeleteMethodologyCommand.run.begin") meth_list = CCommandEx.ProcessInputHandleVec("StmMethodology", [StmMethodology]) if len(meth_list) != 1: plLogger.LogError("Invalid StmMethodology object") return False test_meth = meth_list[0] if test_meth is None: plLogger.LogError("Was unable to find StmMethodology with " + "handle " + StmMethodology + " in the set of installed test cases.") return False # Do not allow the methodology to be deleted if one of its test # cases is currently active (and running) active_tc = meth_man_utils.get_active_test_case() if active_tc is not None: tc_list = test_meth.GetObjects("StmTestCase") for tc in tc_list: if tc.GetObjectHandle() == active_tc.GetObjectHandle(): plLogger.LogDebug("Test Methodology " + test_meth.Get("Name") + " has a current active test case " + tc.Get("Name") + ". Checking to see if it" + " can be deleted.") # Check the results to see if the test is still running if meth_man_utils.is_test_case_running(tc): plLogger.LogError("Can not delete a methodology with " + "an actively running test case.") return False # Remove the active test case meth_man_utils.remove_active_test_relation() break # Delete the methodology and all configured test cases from # the file system if meth_man_utils.methodology_rmdir(test_meth.Get("MethodologyKey")): plLogger.LogDebug("Successfully deleted " + test_meth.Get("Name") + " from disk") else: plLogger.LogError("Failed to delete " + test_meth.Get("Name") + " from disk") return False # Delete the methodology object test_meth.MarkDelete() plLogger.LogDebug("DeleteMethodologyCommand.run.end") return True
def validate(StmMethodology, StmTestCase, InputJson, EnableTieCheck): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.validate.LoadTestMethodologyCommand") # Check that TestMethodologyName exists stc_sys = CStcSystem.Instance() test_meth = meth_man_utils.get_stm_methodology_from_handle(StmMethodology) if test_meth is None: plLogger.LogError("ERROR: Was unable to find StmMethodology with handle " + str(StmMethodology) + " in the list of installed tests.") return "ERROR: Could not find test." test_meth_name = test_meth.Get('TestMethodologyName') plLogger.LogDebug("test_meth_name: " + test_meth_name) install_dir = meth_man_utils.get_methodology_dir(test_meth_name) os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) if not install_dir: return "ERROR: Could not find path to the test." # Check that StmTestCase is in datamodel # If NO StmTestCase is provided, then assume it's the "original" test_case_name = "" if StmTestCase == 0: plLogger.LogDebug("No StmTestCase is provided, use the methodology itself") test_case_name = "original" test_case_path = install_dir else: hnd_reg = CHandleRegistry.Instance() test_case = hnd_reg.Find(StmTestCase) if test_case is None: plLogger.LogError("ERROR: Was unable to find StmTestCase" + " in the list of installed test cases.") return "ERROR: Could not find test case." test_case_name = test_case.Get('TestCaseName') test_case_path = test_case.Get('Path') plLogger.LogDebug("test_case_name: " + test_case_name) plLogger.LogDebug("test_case_path: " + str(test_case_path)) if not os.path.exists(test_case_path): return "ERROR: Could not find path to the test case." full_txml_path = os.path.join(test_case_path, mgr_const.MM_META_FILE_NAME) plLogger.LogDebug("full_txml_path: " + str(full_txml_path)) if os.path.isfile(full_txml_path): test_instance_name = txml_utils.extract_test_case_name_from_file(full_txml_path) plLogger.LogDebug("test_instance_name: " + str(test_instance_name)) if test_instance_name == test_case_name: return "" plLogger.LogDebug("end.validate.LoadTestMethodologyCommand") return "ERROR: Could not find txml file for test case."
def run(MethodologyKey, TestCaseKey): plLogger = PLLogger.GetLogger('methodology') test_meth = meth_man_utils.get_stm_methodology_from_key(MethodologyKey) if not test_meth: plLogger.LogError("No methodology with key " + MethodologyKey + " exists") return False this_cmd = get_this_cmd() this_cmd.Set('StmMethodology', test_meth.GetObjectHandle()) if not TestCaseKey: return True testcase = meth_man_utils.get_stm_testcase_from_key(test_meth, TestCaseKey) if testcase: this_cmd.Set('StmTestCase', testcase.GetObjectHandle()) else: plLogger.LogError("No test case with key " + TestCaseKey + " exists for " + MethodologyKey) return False return True
def run(): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.run.GetAllTestMethodologiesCommand") hnd_reg = CHandleRegistry.Instance() installed_meths = [] install_dir = meth_man_utils.get_methodology_home_dir() meth_man = meth_man_utils.get_meth_manager() test_meth_list = meth_man.GetObjects("StmMethodology") for test_meth in test_meth_list: installed_meths.append(test_meth.GetObjectHandle()) plLogger.LogDebug("installed_meths: " + str(installed_meths)) this_cmd = hnd_reg.Find(__commandHandle__) this_cmd.SetCollection("StmMethodologyList", installed_meths) this_cmd.Set("TestMethodologyDir", str(install_dir)) plLogger.LogDebug("end.run.GetAllTestMethodologiesCommand") return True
def run(FileName): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.run.ImportTestCommand") plLogger.LogDebug(" FileName: " + FileName) stc_sys = CStcSystem.Instance() common_data_path = stc_sys.GetApplicationCommonDataPath() test_meth_dir = os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR) if not os.path.exists(test_meth_dir): plLogger.LogDebug("Adding testMeth directory: " + str(test_meth_dir)) os.mkdir(test_meth_dir) # Unzip to temp directory nice_ts = txml_utils.get_timestamp_ymd_hms() temp_dir = os.path.join(test_meth_dir, "temp_" + str(nice_ts)) if not os.path.exists(temp_dir): os.makedirs(temp_dir) with zipfile.ZipFile(FileName, "r") as z: z.extractall(temp_dir) meta_file = os.path.join(temp_dir, mgr_const.MM_TEST_CASE_SUBDIR, mgr_const.MM_META_FILE_NAME) seq_file = os.path.join(temp_dir, mgr_const.MM_SEQUENCER_FILE_NAME) if not os.path.isfile(meta_file): plLogger.LogError("Unable to extract TXML file!") return False if not os.path.isfile(seq_file): plLogger.LogError("Unable to extract sequencer file!") return False # Read the TXML file for the test name test_name = txml_utils.extract_methodology_name_from_file(meta_file) if not test_name: plLogger.LogError("ERROR: Could not extract test methodology name from the TXML file!") return False plLogger.LogDebug("test_name: " + test_name) if not validate_command_on_disk(seq_file): return False test_meth_test_dir = os.path.join(test_meth_dir, test_name) test_meth_test_case_dir = os.path.join(test_meth_test_dir, mgr_const.MM_TEST_CASE_SUBDIR) plLogger.LogDebug(" test_meth_test_dir: " + str(test_meth_test_dir)) plLogger.LogDebug(" test_meth_test_case_dir: " + str(test_meth_test_case_dir)) if not os.path.exists(test_meth_test_dir): os.makedirs(test_meth_test_dir) if not os.path.exists(test_meth_test_case_dir): os.makedirs(test_meth_test_case_dir) # FIXME: # Need to handle multiple copies of the TXML file shutil.copy(seq_file, test_meth_test_dir) shutil.copy(meta_file, test_meth_test_case_dir) # Add BLL objects meth_man_utils.build_test_methodology(test_meth_test_dir, use_txml=True) # Clean up # Delete the temporary directory and its contents os.remove(meta_file) os.rmdir(os.path.join(temp_dir, mgr_const.MM_TEST_CASE_SUBDIR)) os.remove(seq_file) os.rmdir(temp_dir) plLogger.LogDebug("end.run.ImportTestCommand") return True
def run(StmMethodology, StmTestCase, InputJson, EnableTieCheck): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.run.LoadTestMethodologyCommand") stc_sys = CStcSystem.Instance() # Keep this in to prevent PEP8 errors as the ParentConfig # of the LoadFromXmlCommand is commented out or uncommented out. plLogger.LogDebug("InputJson: " + str(InputJson)) hnd_reg = CHandleRegistry.Instance() ctor = CScriptableCreator() # validate() already checks the existence of StmMethodology and StmTestCase # No need to do the checking again here stm_meth = meth_man_utils.get_stm_methodology_from_handle(StmMethodology) plLogger.LogDebug("stm_meth: " + stm_meth.Get("TestMethodologyName")) test_meth_path = stm_meth.Get("Path") plLogger.LogDebug("test_meth_path: " + str(test_meth_path)) stm_test_case = None # If NO StmTestCase is provided, then assume it's the "original" if StmTestCase == 0: plLogger.LogDebug("stm_test_case: original") test_case_path = test_meth_path else: hnd_reg = CHandleRegistry.Instance() stm_test_case = hnd_reg.Find(StmTestCase) plLogger.LogDebug("stm_test_case: " + stm_test_case.Get("TestCaseName")) test_case_path = stm_test_case.Get("Path") if EnableTieCheck: # In the worst case, a profile test won't fit. If the test isn't # profile based, we currently have no way of determining if it will # run successfully or not. can_run = check_tie_for_profile_based_test(InputJson, stm_test_case) plLogger.LogDebug("test_case_path: " + str(test_case_path)) if not validate_command_on_disk(os.path.join(test_case_path, mgr_const. MM_SEQUENCER_FILE_NAME)): plLogger.LogError("validate_command_on_disk failed for: " + test_meth_path + "/" + mgr_const.MM_SEQUENCER_FILE_NAME) return False # Non profile-based tests can always run.... This is kind of a # strange check until we figure out how to validate non # profile-based tests. can_run = True # Load if can_run: loadCmd = ctor.CreateCommand("LoadFromXml") loadCmd.Set("FileName", os.path.join(test_case_path, mgr_const.MM_SEQUENCER_FILE_NAME)) # FIXME !!!!!! # If the ParentConfig is set to empty string (""), then the GUI works and TCL crashes. # If the ParentConfig is set to project, then the GUI crashes and TCL works # loadCmd.Set("ParentConfig", project.GetObjectHandle()) loadCmd.Execute() if StmTestCase == 0: # Can only do this if we're loading a real test case, not the original meth_man_utils.set_active_test_case(stm_test_case) else: # FIXME: # We obviously need more information here. plLogger.LogError("ERROR: Can not load Test Methodology") return False # Process the ports (now that the config is loaded) # Break the JSON into ports and params sections ports_json = None params_json = None portgroups_json = None if InputJson != "": input_json = json.loads(InputJson) if "portgroups" in input_json.keys(): portgroups_json = input_json["portgroups"] if "params" in input_json.keys(): params_json = input_json["params"] plLogger.LogDebug("calling relocate and bring ports online") # Relocate and bring ports online as necessary if portgroups_json is not None: process_portgroups(portgroups_json) else: process_ports(ports_json) if params_json is not None: plLogger.LogDebug("params_json: " + json.dumps(params_json)) # Fill in the input JSON if it exists 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("InputJson", json.dumps(params_json)) break plLogger.LogDebug("end.run.LoadTestMethodologyCommand") return True
def run(MethodologyJson): plLogger = PLLogger.GetLogger("methodology") plLogger.LogDebug("CreateMethodologyTestCaseCommand.run") this_cmd = get_this_cmd() err_str, meta = json_utils.load_json(MethodologyJson) if err_str != "": plLogger.LogError(err_str) this_cmd.Set("Status", err_str) return False meth_key = meta["methodology_key"] meth_obj = meth_man_utils.get_stm_methodology_from_key(meth_key) if meth_obj is None: plLogger.LogDebug("Invalid methodology key: " + str(meth_key)) return False if not meth_obj.IsTypeOf("StmMethodology"): plLogger.LogError("Invalid methodology object: " + meth_obj.Get("Name")) return False # Get a new test case key tc_key = meth_man_utils.get_new_testcase_key(meth_obj) # Create a directory for the test case plLogger.LogDebug("create a directory under " + meth_obj.Get("Path")) target_dir = meth_man_utils.methodology_test_case_mkdir(meth_key, tc_key) if not target_dir: plLogger.LogError("Failed to create test case directory") return False source_dir = meth_obj.Get("Path") plLogger.LogDebug("Source directory is " + source_dir) plLogger.LogDebug("Target directory is " + target_dir) # Copy the files from the source directory to the new target directory src_files = os.listdir(source_dir) for file_name in src_files: full_file_name = os.path.join(source_dir, file_name) if os.path.isfile(full_file_name): shutil.copy(full_file_name, target_dir) # Now that the target files are in place, generate the meta file meta["test_case_key"] = tc_key MethodologyJson = json.dumps(meta) plLogger.LogDebug("meta = " + MethodologyJson) meta_json_file = os.path.join(target_dir, mgr_const.MM_META_JSON_FILE_NAME) # Make sure we can write to the file changed_permissions = False if os.path.exists(meta_json_file): mode = os.stat(meta_json_file)[stat.ST_MODE] os.chmod(meta_json_file, mode | stat.S_IWRITE) changed_permissions = True # Open or create the json file and write to it f = open(meta_json_file, "w") f.write(MethodologyJson) f.close() # Put permissions back the way they were if changed_permissions: os.chmod(meta_json_file, mode) # Now create the data model portion that corresponds to the test case ctor = CScriptableCreator() test_case = ctor.Create("StmTestCase", meth_obj) # The meth display_name may not be correct, but it is more informative than nothing... test_case.Set("Name", meta["display_name"]) test_case.Set("TestCaseKey", tc_key) test_case.Set("Path", target_dir) this_cmd.Set("TestCaseKey", tc_key) plLogger.LogDebug("CreateMethodologyTestCaseCommand.run.exit") return True
def run(TestCaseSrc, TestCaseName, TestCaseDescription): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.run.CreateTestCaseCommand") hnd_reg = CHandleRegistry.Instance() meth_src_obj = hnd_reg.Find(TestCaseSrc) meth_obj = None if meth_src_obj is None: plLogger.LogDebug("Invalid TestCaseSrc handle: " + str(TestCaseSrc)) if meth_src_obj.IsTypeOf("StmMethodology"): meth_obj = meth_src_obj elif meth_obj.IsTypeOf("StmTestCase"): # TODO: Support creation from another test case plLogger.LogError("Test Case creation from existing test cases is not " + "currently supported.") meth_obj = meth_src_obj.GetParent() return False else: plLogger.LogError("Invalid source object: " + meth_src_obj.Get("Name")) return False # Get a new test case key tc_key = meth_man_utils.get_new_testcase_key(meth_obj) # Create a directory for the test case plLogger.LogDebug("create a directory under " + meth_obj.Get("Path")) meth_key = meth_obj.Get("MethodologyKey") target_dir = meth_man_utils.methodology_test_case_mkdir(meth_key, tc_key) if not target_dir: plLogger.LogError("Failed to create test case directory") return False source_dir = meth_obj.Get("Path") plLogger.LogDebug("Source directory is " + source_dir) plLogger.LogDebug("Target directory is " + target_dir) # Copy the files from the source directory to the new target directory src_files = os.listdir(source_dir) for file_name in src_files: full_file_name = os.path.join(source_dir, file_name) if (os.path.isfile(full_file_name)): shutil.copy(full_file_name, target_dir) # Now that the target files are in place, update the metadata file # Open the TXML file txml_file = os.path.join(target_dir, mgr_const.MM_META_FILE_NAME) if not os.path.exists(txml_file): plLogger.LogError("ERROR: Can't find " + str(txml_file)) return False # Read the TXML txml_tree = etree.parse(txml_file) if txml_tree is None: plLogger.LogError("ERROR: Could not parse TXML located in " + str(txml_file)) return False txml_root = txml_tree.getroot() if txml_root is None: plLogger.LogError("ERROR: Could not parse TXML located in " + str(txml_file)) return False # Update the testInfo section with the name of the test case child = txml_root.find(meta_man.TEST_INFO) if child is not None: child.set(meta_man.TI_TEST_CASE_NAME, TestCaseName) child.set(meta_man.TI_DESCRIPTION, TestCaseDescription) child.set(meta_man.TI_TEST_CASE_KEY, tc_key) # Make sure we can write to the file mode = os.stat(txml_file)[stat.ST_MODE] os.chmod(txml_file, mode | stat.S_IWRITE) # Write the txml out to the file txml_str = etree.tostring(txml_root) f = open(txml_file, "w") f.write("<?xml version=\"1.0\" ?>\n") f.write(txml_str) f.close() # Put permissions back the way they were os.chmod(txml_file, mode) # Now create the data model portion that corresponds to the test case ctor = CScriptableCreator() test_case = ctor.Create("StmTestCase", meth_obj) test_case.Set("Name", TestCaseName) test_case.Set("TestCaseKey", tc_key) test_case.Set("Path", target_dir) this_cmd = get_this_cmd() this_cmd.Set("StmTestCase", test_case.GetObjectHandle()) plLogger.LogDebug("end.run.CreateTestCaseCommand") return True
def run(TestMethodologyName, InputJson, TestCaseName, FileName): plLogger = PLLogger.GetLogger('methodology') plLogger.LogDebug("begin.run.SaveTestCaseCommand") stc_sys = CStcSystem.Instance() project = stc_sys.GetObject("Project") ctor = CScriptableCreator() # If TestCaseName is "" then overwrite the "original" TXML file # Otherwise, create a new TXML file is_overwrite = False test_case_name = TestCaseName if test_case_name == "": plLogger.LogDebug("This is an overwrite operation") test_case_name = meta_man.TEST_INSTANCE_ORIGINAL is_overwrite = True plLogger.LogDebug("TestCaseName: " + TestCaseName) plLogger.LogDebug("test_case_name: " + test_case_name) plLogger.LogDebug("is_overwrite: " + str(is_overwrite)) if project is None: plLogger.LogError("Invalid Project object") return False # Find the TXML file (source) test_meth_path = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR, TestMethodologyName) txml_file = os.path.join(test_meth_path, mgr_const.MM_TEST_CASE_SUBDIR, mgr_const.MM_META_FILE_NAME) if not os.path.exists(txml_file): plLogger.LogError("ERROR: Can't find " + str(txml_file)) return False # Read the TXML txml_tree = etree.parse(txml_file) txml_root = txml_tree.getroot() plLogger.LogDebug("Processing TXML: " + etree.tostring(txml_root)) if txml_root is None: plLogger.LogError("ERROR: Could not parse TXML located in " + str(txml_file)) return False # Parse the JSON into ports/params input_json = json.loads(InputJson) new_params_dict = ast.literal_eval(json.dumps(input_json["params"])) new_ports_dict = ast.literal_eval(json.dumps(input_json["ports"])) plLogger.LogDebug(" new_params_dict: " + str(new_params_dict)) plLogger.LogDebug(" new_ports_dict: " + str(new_ports_dict)) for child in txml_root: plLogger.LogDebug("Found tag: " + child.tag) if child.tag == meta_man.TEST_INFO: plLogger.LogDebug("process test info section") if not is_overwrite: plLogger.LogDebug("Setting new test case name to: " + test_case_name) # Change the name of the testCase child.set(meta_man.TI_TEST_CASE_NAME, test_case_name) else: plLogger.LogDebug("Using existing test case name: " + child.get(meta_man.TI_TEST_CASE_NAME)) elif child.tag == meta_man.TEST_RESOURCES: plLogger.LogDebug("process test resources section") PORT_STR = ".//" + meta_man.TR_RESOURCE_GROUPS + \ "/" + meta_man.TR_RESOURCE_GROUP + \ "/" + meta_man.TR_PORT_GROUPS + \ "/" + meta_man.TR_PORT_GROUP + \ "/" + meta_man.TR_PORTS + \ "/" + meta_man.TR_PORT port_list = child.findall(PORT_STR) for port in port_list: if port.tag == meta_man.TR_PORT: plLogger.LogDebug("Process port: " + port.get(meta_man.TR_NAME)) update_port_tag(port, new_ports_dict) elif (child.tag == meta_man.EDITABLE_PARAMS): plLogger.LogDebug("process test params section") PARAM_STR = ".//" + meta_man.EP_PARAM_GROUPS + \ "/" + meta_man.EP_PARAM_GROUP + \ "/" + meta_man.EP_PARAMS + \ "/" + meta_man.EP_PARAM param_list = child.findall(PARAM_STR) for param in param_list: plLogger.LogDebug("Found param)") prop_val = None prop_id = None # Process attributes for attr in param: if attr.tag == meta_man.EP_ATTR: attr_name = attr.get(meta_man.EP_NAME) if attr_name == meta_man.EP_PROP_ID: prop_id = attr.get(meta_man.EP_VALUE) elif attr_name == meta_man.EP_DEFAULT: prop_val = attr.get(meta_man.EP_VALUE) default_val_elem = attr plLogger.LogDebug(" prop_val: " + str(prop_val)) plLogger.LogDebug(" prop_id: " + str(prop_id)) if prop_id is not None and prop_val is not None: if prop_id in new_params_dict.keys(): if default_val_elem is None: plLogger.LogError("ERROR: Could not find XML element for " + str(prop_id)) else: default_val_elem.set(meta_man.EP_VALUE, new_params_dict[prop_id]) else: plLogger.LogWarn(" prop_id and or prop_val was none - no value to set") # Test case path tc_path = os.path.join(test_meth_path, mgr_const.MM_TEST_CASE_SUBDIR) if not os.path.exists(tc_path): os.makedirs(tc_path) if is_overwrite is False: plLogger.LogDebug(" create a new testcase...") # Create new TXML filename (original filename + timestamp) if FileName == "": nice_ts = txml_utils.get_timestamp_ymd_hms() file_prefix = str(os.path.splitext(mgr_const.MM_META_FILE_NAME)[0]) new_tc_file = file_prefix + "_" + nice_ts + ".txml" else: new_tc_file = FileName plLogger.LogDebug("Writing new Test Case: " + str(new_tc_file)) full_path = os.path.join(tc_path, new_tc_file) # Add a new test case meth_man = meth_man_utils.get_meth_manager() meth_list = meth_man.GetObjects("StmMethodology") for test_meth in meth_list: if test_meth.Get("TestMethodologyName") == TestMethodologyName: test_case = ctor.Create("StmTestCase", test_meth) test_case.Set("TestCaseName", TestCaseName) test_case.Set("Path", full_path) else: plLogger.LogDebug("Overwriting values in existing " + str(mgr_const.MM_META_FILE_NAME)) full_path = os.path.join(tc_path, mgr_const.MM_META_FILE_NAME) txml_str = etree.tostring(txml_root) plLogger.LogDebug(" txml_str: " + str(txml_str)) plLogger.LogDebug(" writing file to " + str(full_path)) f = open(full_path, "w") f.write("<?xml version=\"1.0\" ?>\n") f.write(txml_str) f.close() hnd_reg = CHandleRegistry.Instance() this_cmd = hnd_reg.Find(__commandHandle__) this_cmd.Set("TxmlFileName", full_path) plLogger.LogDebug("end.run.SaveTestCaseCommand") return True