def test_find_file_across_common_paths(stc): common_data_path = meth_man_utils.get_common_data_path() cleanup_info = UnitTestUtils.create_meth_tree_test_files() try: p1 = meth_man_utils.find_file_across_common_paths('file1') assert p1 == os.path.normpath(os.path.join(common_data_path, 'file1')) p2 = meth_man_utils.find_file_across_common_paths('file2') assert p2 == os.path.normpath(os.getcwd() + '/file2') p3 = meth_man_utils.find_file_across_common_paths('file3') assert p3 == '' p3 = meth_man_utils.find_file_across_common_paths('file3', True) assert p3 == '' p3 = meth_man_utils.find_file_across_common_paths('file3', True, True) assert p3 == '' p4 = meth_man_utils.find_file_across_common_paths('file4') assert p4 == '' p4 = meth_man_utils.find_file_across_common_paths('file4', False, True) assert p4 == '' p4 = meth_man_utils.find_template_across_common_paths('file4') assert p4 == '' p4 = meth_man_utils.find_file_across_common_paths('file4', True, False) expected = os.path.normpath(os.path.join( common_data_path, mgr_const.MM_SCRIPTS_DIR, 'file4')) assert p4 == expected p4 = meth_man_utils.find_script_across_common_paths('file4') assert p4 == expected p5 = meth_man_utils.find_file_across_common_paths('file5') assert p5 == '' p5 = meth_man_utils.find_file_across_common_paths('file5', False, True) expected = os.path.normpath( os.path.join(common_data_path, mgr_const.MM_TEMPLATE_DIR, 'file5')) assert p5 == expected p5 = meth_man_utils.find_template_across_common_paths('file5') assert p5 == expected p5 = meth_man_utils.find_file_across_common_paths('file5', True, False) assert p5 == '' p5 = meth_man_utils.find_script_across_common_paths('file5') assert p5 == '' finally: UnitTestUtils.cleanup_meth_tree_test_files(cleanup_info) return
def test_delete(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_delete.begin") ctor = CScriptableCreator() hnd_reg = CHandleRegistry.Instance() meth_key = "UNITTEST_DEL" UnitTestUtils.create_fake_installed_test_meth(meth_key, []) UnitTestUtils.add_fake_test_case(meth_key, [], meth_key + "-1") UnitTestUtils.add_fake_test_case(meth_key, [], meth_key + "-2") # Update the BLL objects meth_man_utils.build_test_methodology_manager(use_txml=True) meth_handle = UnitTestUtils.get_methodology_handle(meth_key) assert meth_handle meth_obj = hnd_reg.Find(meth_handle) assert meth_obj is not None tc_obj_list = meth_obj.GetObjects("StmTestCase") assert len(tc_obj_list) == 2 tc_obj1 = None tc_obj2 = None for tc_obj in tc_obj_list: if tc_obj.Get("TestCaseKey") == meth_key + "-1": tc_obj1 = tc_obj elif tc_obj.Get("TestCaseKey") == meth_key + "-2": tc_obj2 = tc_obj assert tc_obj1 tc_obj1_path = tc_obj1.Get("Path") assert tc_obj2 tc_obj2_path = tc_obj2.Get("Path") # Delete an installed test case cmd = ctor.CreateCommand(PKG + ".DeleteTestCaseCommand") cmd.Set("StmTestCase", tc_obj2.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Check the path assert os.path.exists(tc_obj1_path) assert not os.path.exists(tc_obj2_path) # Delete installed test methodology cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() stc_sys = CStcSystem.Instance() common_data_path = stc_sys.GetApplicationCommonDataPath() install_dir = os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR) test_meth_dir = os.path.join(install_dir, meth_key) assert os.path.exists(test_meth_dir) is False plLogger.LogInfo("test_delete.end")
def test_create_new_testcase(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_create_new_testcase") # Test empty meth key err_msg, tc_key, tc_obj_hnd = meth_man_utils.create_new_testcase("", "") assert err_msg == "Methodology key appears to be invalid." assert tc_key is None assert tc_obj_hnd is None # Create a fresh copy of the UnitTestMeth methodology... meth_man_utils.methodology_rmdir("UnitTestMeth") meth_path = meth_man_utils.methodology_mkdir("UnitTestMeth") UnitTestUtils.create_fake_installed_test_meth("UnitTestMeth", []) meth_man_utils.build_test_methodology(meth_path, True) err_msg, tc_key, tc_obj_hnd = meth_man_utils.create_new_testcase("UnitTestMeth", "tcx") assert err_msg == "" assert tc_key is not None assert tc_obj_hnd is not None # Clean up... meth_man_utils.methodology_rmdir("UnitTestMeth") return
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 disabled_test_load_with_json(stc): plLogger = PLLogger.GetLogger("test_load_with_json") plLogger.LogInfo("begin") ctor = CScriptableCreator() project = CStcSystem.Instance().GetObject("Project") sequencer = CStcSystem.Instance().GetObject("Sequencer") hnd_reg = CHandleRegistry.Instance() cmd_name = "Ipv4NetworkProfileGroupCommand" pkg_name = "spirent.methodology." create_cmd = ctor.CreateCommand(pkg_name + cmd_name) insert_cmd = ctor.CreateCommand("SequencerInsertCommand") insert_cmd.SetCollection("CommandList", [create_cmd.GetObjectHandle()]) insert_cmd.Execute() exposedConfig = ctor.Create("ExposedConfig", project) prop1 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop1, create_cmd, pkg_name + cmd_name, "DeviceCount") prop2 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop2, create_cmd, pkg_name + cmd_name, "RouterId") prop3 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop3, create_cmd, pkg_name + cmd_name, "Ipv4Addr") test_name = "TestLoadWithJson" test_key = "JsonTestKey" # Delete the methodology we are about to create just in case # there was an error on a previous run. test_meth_obj = meth_man_utils.get_stm_methodology_from_key(test_key) if test_meth_obj: # Delete installed test methodology cmd = ctor.CreateCommand("spirent.methodology.manager." "DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Publish as a methodology cmd = ctor.CreateCommand("spirent.methodology.manager.PublishMethodologyCommand") cmd.Set("MethodologyName", test_name) cmd.Set("MethodologyKey", test_key) cmd.Set("MinPortCount", "0") cmd.Execute() cmd.MarkDelete() # Reset Config cmd = ctor.CreateCommand("ResetConfigCommand") cmd.Set("Config", CStcSystem.Instance().GetObjectHandle()) cmd.Execute() cmd.MarkDelete() sequencer = CStcSystem.Instance().GetObject("Sequencer") cmd_list = sequencer.GetObjects("Command") assert len(cmd_list) == 0 meth_handle = UnitTestUtils.get_methodology_handle(test_name) assert meth_handle # TODO: Create a test case instead of running the methodology # itself. # Set up JSON input json_input = "{ \"ports\": {}, \"params\" : {\"" + prop1.Get("EPNameId") + "\" : 101, " + \ "\"" + prop2.Get("EPNameId") + "\" : \"188.0.0.5\", " + \ "\"" + prop3.Get("EPNameId") + "\" : \"172.0.17.5\" } }" active_test = meth_man_utils.get_active_test_case() assert active_test is None # Load the test methodology created earlier # Set the JSON input cmd = ctor.CreateCommand("spirent.methodology.manager." "LoadTestMethodologyCommand") meth = meth_man_utils.get_stm_methodology_from_key(test_key) assert meth is not None cmd.Set("StmMethodology", meth.GetObjectHandle()) cmd.Set("InputJson", json_input) cmd.Execute() # Check the command sequence cmd_hnd_list = sequencer.GetCollection("CommandList") assert len(cmd_hnd_list) == 1 tlgc = hnd_reg.Find(cmd_hnd_list[0]) assert tlgc is not None assert tlgc.IsTypeOf(pkg_name + "manager.MethodologyGroupCommand") is True cmd_hnd_list = tlgc.GetCollection("CommandList") assert len(cmd_hnd_list) == 1 create_cmd = hnd_reg.Find(cmd_hnd_list[0]) assert create_cmd.IsTypeOf(pkg_name + cmd_name) is True # Check defaults assert create_cmd.Get("DeviceCount") == 1 assert create_cmd.Get("RouterId") == "192.0.0.1" assert create_cmd.Get("Ipv4Addr") == "192.85.1.3" # Execute a MethodologyGroupCommand tlgc2 = ctor.CreateCommand(pkg_name + "manager.MethodologyGroupCommand") tlgc2.Set("InputJson", tlgc.Get("InputJson")) tlgc2.Execute() tlgc2.MarkDelete() # Check the new defaults assert create_cmd.Get("DeviceCount") == 101 assert create_cmd.Get("RouterId") == "188.0.0.5" assert create_cmd.Get("Ipv4Addr") == "172.0.17.5" # Clean up meth = meth_man_utils.get_stm_methodology_from_key(test_key) cmd = ctor.CreateCommand("spirent.methodology.manager." "DeleteMethodologyCommand") cmd.Set("StmMethodology", meth.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() plLogger.LogInfo("end")
def d_test_save_as_test_case_with_ports(self, stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin") # TODO: Fix this once the test case work is finished if True: plLogger.LogWarn("Fix me after test cases have been repaired.") return ctor = CScriptableCreator() meth_name = "TestMeth_SaveAsTestCase" stc_sys = CStcSystem.Instance() meth_man_pkg = "spirent.methodology.manager" # Defaults port_loc = "//10.14.16.20/2/1" mac_addr = "00:01:94:00:00:01" enable_vlan = False vlan_id = 100 ipv4_addr = "192.85.1.3" plLogger.LogInfo("Create a test package") test_name, name_dict = TestSaveTestCase.make_fake_test_pkg(mac_addr, enable_vlan, vlan_id, ipv4_addr, port_loc, meth_name) # Build a port_map for validation (flip the name_dict) port_map = {} port_map[name_dict[port_loc]] = port_loc plLogger.LogInfo("Import the methodology " + test_name) # Import the test methodology (make available) cmd = ctor.CreateCommand(meth_man_pkg + ".ImportTestCommand") cmd.Set("fileName", test_name + ".stm") cmd.Execute() cmd.MarkDelete() plLogger.LogInfo("Verify that the TXML file exists after import") # Check the TXML file exists install_dir = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) test_meth_dir = os.path.join(install_dir, meth_name) assert os.path.exists(test_meth_dir) test_case_dir = os.path.join(test_meth_dir, mgr_const.MM_TEST_CASE_SUBDIR) assert os.path.exists(test_case_dir) file_list = os.listdir(test_case_dir) assert len(file_list) == 1 meta_file = file_list[0] assert meta_file == mgr_const.MM_META_FILE_NAME plLogger.LogInfo("Verify the TXML file contents haven't changed") # Check TXML defaults TestSaveTestCase.check_txml_values(meta_file, meta_man.TEST_INSTANCE_ORIGINAL, mac_addr, enable_vlan, vlan_id, ipv4_addr, port_map, meth_name) new_port_loc = "//10.14.16.27/2/1" new_mac = "00:01:95:CC:CC:0s" new_enable_vlan = "true" new_vlan = "541" new_ip = "182.0.0.1" # New port_map (for validation) new_port_map = {} new_port_map[name_dict[port_loc]] = new_port_loc # Create JSON string with new defaults json_input = "{\"ports\" : {\"" + name_dict[port_loc] + "\" : \"" + \ new_port_loc + "\"},\"params\" : {\"" + \ name_dict["MacAddr"] + "\" : \"" + new_mac + "\"," + \ " \"" + name_dict["EnableVlan"] + "\" : \"" + new_enable_vlan + "\"," + \ " \"" + name_dict["VlanId"] + "\" : \"" + new_vlan + "\"," + \ " \"" + name_dict["Ipv4Addr"] + "\" : \"" + new_ip + "\" }}" plLogger.LogInfo("Execute SaveTestCaseCommand with json_input: \n" + json_input) # Create a new "instance" of the testcase new_test_case = "MyNewTestCase" cmd = ctor.CreateCommand(meth_man_pkg + ".SaveTestCaseCommand") cmd.Set("TestMethodologyName", test_name) cmd.Set("InputJson", json_input) cmd.Set("TestCaseName", new_test_case) cmd.Execute() # Get the TXML file path new_txml_file_path = cmd.Get("TxmlFileName") new_txml_file = os.path.split(new_txml_file_path)[-1] cmd.MarkDelete() # Check the TXML file exists install_dir = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) test_meth_dir = os.path.join(install_dir, meth_name) assert os.path.exists(test_meth_dir) test_case_dir = os.path.join(test_meth_dir, mgr_const.MM_TEST_CASE_SUBDIR) assert os.path.exists(test_case_dir) file_list = os.listdir(test_case_dir) assert len(file_list) > 1 assert new_txml_file in file_list assert mgr_const.MM_META_FILE_NAME in file_list plLogger.LogInfo("Check the new saved file") TestSaveTestCase.check_txml_values(new_txml_file, new_test_case, new_mac, new_enable_vlan, new_vlan, new_ip, new_port_map, meth_name) plLogger.LogInfo("Verify the original hasn't changed") TestSaveTestCase.check_txml_values(mgr_const.MM_META_FILE_NAME, meta_man.TEST_INSTANCE_ORIGINAL, mac_addr, enable_vlan, vlan_id, ipv4_addr, port_map, meth_name) # Clean up anything that might be left from a previous run meth_handle = UnitTestUtils.get_methodology_handle(meth_name) UnitTestUtils.cleanup_methodology(meth_handle) plLogger.LogInfo("end")
def d_test_save_test_case(self, stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin") # TODO: Fix this once the test case work is finished if True: plLogger.LogWarn("Fix me after test cases have been repaired.") return ctor = CScriptableCreator() meth_name = "TestMeth_SaveTestCase" stc_sys = CStcSystem.Instance() meth_man_pkg = "spirent.methodology.manager" # Defaults mac_addr = "00:01:94:00:00:01" enable_vlan = False vlan_id = 100 ipv4_addr = "192.85.1.3" plLogger.LogInfo("Create and export the test") test_name, name_dict = TestSaveTestCase.make_fake_test_pkg(mac_addr, enable_vlan, vlan_id, ipv4_addr, "", meth_name) plLogger.LogInfo("name_dict: " + str(name_dict)) plLogger.LogInfo("test_name: " + test_name) new_mac = "00:01:95:CC:CC:05" new_enable_vlan = "true" new_vlan = "541" new_ip = "182.0.0.1" # Create JSON string with new defaults json_input = "{ \"ports\" : {}, \"params\" : {\"" + name_dict["MacAddr"] + "\" : \"" + \ new_mac + "\"," + \ " \"" + name_dict["EnableVlan"] + "\" : \"" + new_enable_vlan + "\"," + \ " \"" + name_dict["VlanId"] + "\" : \"" + new_vlan + "\"," + \ " \"" + name_dict["Ipv4Addr"] + "\" : \"" + new_ip + "\" } }" plLogger.LogInfo("Execute save test with json_input: \n" + json_input) # Change the defaults in "original" TXML by setting TestCaseName to "" cmd = ctor.CreateCommand(meth_man_pkg + ".SaveTestCaseCommand") cmd.Set("TestMethodologyName", test_name) cmd.Set("InputJson", json_input) cmd.Set("TestCaseName", "") cmd.Execute() cmd.MarkDelete() # Check the TXML file exists install_dir = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) test_meth_dir = os.path.join(install_dir, meth_name) assert os.path.exists(test_meth_dir) test_case_dir = os.path.join(test_meth_dir, mgr_const.MM_TEST_CASE_SUBDIR) assert os.path.exists(test_case_dir) file_list = os.listdir(test_case_dir) assert len(file_list) == 1 meta_file = file_list[0] assert meta_file == mgr_const.MM_META_FILE_NAME # Check TXML defaults plLogger.LogInfo("check original txml has new values") TestSaveTestCase.check_txml_values(meta_file, meta_man.TEST_INSTANCE_ORIGINAL, new_mac, new_enable_vlan, new_vlan, new_ip, None, meth_name) # Clean up anything that might be left meth_handle = UnitTestUtils.get_methodology_handle(meth_name) UnitTestUtils.cleanup_methodology(meth_handle) plLogger.LogInfo("end")
def test_delete_with_active_testcase(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_delete_active_test.begin") ctor = CScriptableCreator() hnd_reg = CHandleRegistry.Instance() meth_key = "UNITTEST_DEL" UnitTestUtils.create_fake_installed_test_meth(meth_key, []) UnitTestUtils.add_fake_test_case(meth_key, [], meth_key + "-1") # Update the BLL objects meth_man_utils.build_test_methodology_manager(use_txml=True) meth_man = meth_man_utils.get_meth_manager() meth_handle = UnitTestUtils.get_methodology_handle(meth_key) assert meth_handle meth_obj = hnd_reg.Find(meth_handle) assert meth_obj is not None meth_path = meth_obj.Get("Path") assert os.path.exists(meth_path) tc_obj = meth_obj.GetObject("StmTestCase") assert tc_obj tc_path = tc_obj.Get("Path") assert os.path.exists(tc_path) # Set up the test case to look as if it were active # Set the active test case meth_man_utils.set_active_test_case(tc_obj) # Create the results object and set its status res_obj = ctor.Create("StmTestResult", tc_obj) status_dict = {"execStatus": "running", "verdict": "created", "verdictExplanation": "Not Defined"} res_obj.Set("Status", json.dumps(status_dict)) # Try to delete the methodology cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj.GetObjectHandle()) cmd.Execute() assert cmd.Get("PassFailState") == "FAILED" cmd.MarkDelete() # Check the bll objects found_hnd = False for meth in meth_man.GetObjects("StmMethodology"): if meth.GetObjectHandle() == meth_handle: found_hnd = True break assert found_hnd # Check the active test case assert meth_man_utils.get_active_test_case().GetObjectHandle() == \ tc_obj.GetObjectHandle() # Check the path assert os.path.exists(tc_path) assert os.path.exists(meth_path) # Set the testcase to completed status_dict = {"execStatus": "completed", "verdict": "created", "verdictExplanation": "Not Defined"} res_obj.Set("Status", json.dumps(status_dict)) # Try to delete the methodology cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj.GetObjectHandle()) cmd.Execute() assert cmd.Get("PassFailState") == "PASSED" cmd.MarkDelete() # Check the bll objects found_hnd = False for meth in meth_man.GetObjects("StmMethodology"): if meth.GetObjectHandle() == meth_handle: found_hnd = True break assert not found_hnd # Check the active test case assert meth_man_utils.get_active_test_case() is None # Check the path assert not os.path.exists(meth_path) assert not os.path.exists(tc_path) stc_sys = CStcSystem.Instance() common_data_path = stc_sys.GetApplicationCommonDataPath() install_dir = os.path.join(common_data_path, mgr_const.MM_TEST_METH_DIR) test_meth_dir = os.path.join(install_dir, meth_key) assert os.path.exists(test_meth_dir) is False plLogger.LogInfo("test_delete_active_test.end")
def disabled_test_export_import_load_loose_ports(self, stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin.test_export_import_load_loose_ports") ctor = CScriptableCreator() stc_sys = CStcSystem.Instance() project = stc_sys.GetObject("Project") port = ctor.Create("Port", project) etcu = ctor.Create("EthernetCopper", port) port.AddObject(etcu, RelationType("ActivePhy")) port.Set("Location", "//10.14.18.4/1/1") port_id = get_unique_property_id(port, "Location") stak_cmd_name = "spirent.methodology.Ipv4NetworkProfileGroupCommand" stak_cmd = ctor.CreateCommand(stak_cmd_name) stak_cmd.SetCollection("PortList", [port.GetObjectHandle()]) insert_cmd = ctor.CreateCommand("SequencerInsertCommand") insert_cmd.SetCollection("CommandList", [stak_cmd.GetObjectHandle()]) insert_cmd.Execute() # Expose properties exposed_config = ctor.Create("ExposedConfig", project) # MacAddr mac_prop = ctor.Create("ExposedProperty", exposed_config) mac_prop_id = UnitTestUtils.bind(mac_prop, stak_cmd, stak_cmd_name, "MacAddr") # EnableVlan enable_prop = ctor.Create("ExposedProperty", exposed_config) enable_prop_id = UnitTestUtils.bind(enable_prop, stak_cmd, stak_cmd_name, "EnableVlan") # VlanId vlan_prop = ctor.Create("ExposedProperty", exposed_config) vlan_prop_id = UnitTestUtils.bind(vlan_prop, stak_cmd, stak_cmd_name, "VlanId") test_name = "TestLoosePorts" # Delete the methodology we are about to create just in case # there was an error on a previous run. test_meth_obj = meth_man_utils.get_stm_methodology_from_key(meth_key) if test_meth_obj: # Delete installed test methodology cmd = ctor.CreateCommand("spirent.methodology.manager." "DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Publish methodology cmd = ctor.CreateCommand(PKG + ".PublishMethodologyCommand") cmd.Set("MethodologyName", test_name) cmd.SetCollection("FeatureIdList", ["Feature1"]) cmd.Execute() cmd.MarkDelete() # Reset Config cmd = ctor.CreateCommand("ResetConfigCommand") cmd.Set("Config", CStcSystem.Instance().GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Load the test methodology created earlier # Use mock to prevent the AttachPortsCommand in the LoadTestMethodologyCommand # from being executed. LoadTestMethodologyCommand.attach_ports = MagicMock() # JSON Input json_input = "{\"ports\" : {\"" + port_id + "\" : \"//10.14.16.27/2/2\"}, " + \ "\"params\" : {\"" + mac_prop_id + "\" : \"55:55:55:55:55:55\", " + \ "\"" + enable_prop_id + "\" : \"TRUE\", \"" + vlan_prop_id + "\" : 555} }" plLogger.LogInfo("json_input: " + json_input) # Call run directly # Note that 0 is an invalid STC handle. Asking the HandleRegistry for # it will result in None. # Last arg "1" is to turn on TIE check. "0" will turn off the check meth = meth_man_utils.get_stm_methodology_from_key(meth_key) assert meth is not None LoadTestMethodologyCommand.run(meth.GetObjectHandle(), 0, json_input, 1) # Check the loaded objects project = CStcSystem.Instance().GetObject("Project") port_list = project.GetObjects("Port") assert len(port_list) == 1 # Check the port location has been reconfigured properly assert port_list[0].Get("Location") == "//10.14.16.27/2/2" # Note that one of the exposed properties is the port location # that is tacked on automatically exp_conf = project.GetObject("ExposedConfig") exp_prop_list = exp_conf.GetObjects("ExposedProperty") assert len(exp_prop_list) == 4 found_location_prop = False for exp_prop in exp_prop_list: if exp_prop.Get("EPNameId") == port_id: found_location_prop = True assert found_location_prop is True # Clean up meth_man_utils.remove_active_test_relation() meth = meth_man_utils.get_stm_methodology_from_key(meth_key) cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() plLogger.LogInfo("end.test_export_import_load_loose_ports")
def test_GetAllTestMethodologiesCommand(self, stc): ctor = CScriptableCreator() hnd_reg = CHandleRegistry.Instance() plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin.test_GetAllTestMethodologiesCommand") test_pkg1 = "UNITTEST_GETALL1" test_pkg2 = "UNITTEST_GETALL2" test_pkg3 = "UNITTEST_GETALL3" UnitTestUtils.create_fake_installed_test_meth(test_pkg1, []) UnitTestUtils.create_fake_installed_test_meth(test_pkg2, []) UnitTestUtils.create_fake_installed_test_meth(test_pkg3, []) UnitTestUtils.add_fake_test_case(test_pkg1, [], "UNITTEST_GETALL1-1") UnitTestUtils.add_fake_test_case(test_pkg1, [], "UNITTEST_GETALL1-2") UnitTestUtils.add_fake_test_case(test_pkg1, [], "UNITTEST_GETALL1-3") UnitTestUtils.add_fake_test_case(test_pkg3, [], "UNITTEST_GETALL3-1") # Manually update TestMethodologyManager cmd = ctor.CreateCommand(PKG + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() # Get all installed test methodologies list_cmd = ctor.CreateCommand(PKG + ".GetAllTestMethodologiesCommand") list_cmd.Execute() test_meth_handle_list = list_cmd.GetCollection("StmMethodologyList") list_cmd.MarkDelete() meth_key_list = [] meth_obj1 = None meth_obj2 = None meth_obj3 = None for meth_handle in test_meth_handle_list: meth_obj = hnd_reg.Find(meth_handle) assert meth_obj is not None meth_key = meth_obj.Get("MethodologyKey") if meth_key == test_pkg1: meth_obj1 = meth_obj elif meth_key == test_pkg2: meth_obj2 = meth_obj elif meth_key == test_pkg3: meth_obj3 = meth_obj assert meth_obj1 is not None assert meth_obj2 is not None assert meth_obj3 is not None cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj1.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj2.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj3.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Manually update TestMethodologyManager cmd = ctor.CreateCommand(PKG + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() # Get all installed test methodologies list_cmd = ctor.CreateCommand(PKG + ".GetAllTestMethodologiesCommand") list_cmd.Execute() test_meth_handle_list = list_cmd.GetCollection("StmMethodologyList") list_cmd.MarkDelete() meth_key_list = [] for meth_handle in test_meth_handle_list: meth_obj = hnd_reg.Find(meth_handle) meth_key_list.append(meth_obj.Get("MethodologyKey")) assert test_pkg1 not in meth_key_list assert test_pkg2 not in meth_key_list assert test_pkg3 not in meth_key_list list_cmd.MarkDelete() plLogger.LogInfo("end.test_GetAllTestMethodologiesCommand")
def disabled_test_RemoveMethodologyGroupCommand(self, stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("begin.test_RemoveMethodologyGroupCommand") ctor = CScriptableCreator() project = CStcSystem.Instance().GetObject("Project") sequencer = CStcSystem.Instance().GetObject("Sequencer") cmd_name = "ArpNdStartCommand" stak_cmd_name = "spirent.methodology.Ipv4NetworkProfileGroupCommand" arp_cmd = ctor.CreateCommand(cmd_name) stak_cmd = ctor.CreateCommand(stak_cmd_name) insert_cmd = ctor.CreateCommand("SequencerInsertCommand") insert_cmd.SetCollection("CommandList", [arp_cmd.GetObjectHandle(), stak_cmd.GetObjectHandle()]) insert_cmd.Execute() exposedConfig = ctor.Create("ExposedConfig", project) prop1 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop1, arp_cmd, cmd_name, "ArpNdOption") prop4 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop4, stak_cmd, stak_cmd_name, "DeviceCount") test_name = "TestMethRemoveGroup" meth_key = "UNITTEST_RM_GRP" # Delete the methodology we are about to create just in case # there was an error on a previous run. test_meth_obj = meth_man_utils.get_stm_methodology_from_key(meth_key) if test_meth_obj: # Delete installed test methodology cmd = ctor.CreateCommand("spirent.methodology.manager." "DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Publish methodology cmd = ctor.CreateCommand(PKG + ".PublishMethodologyCommand") cmd.Set("MethodologyName", test_name) cmd.Set("MethodologyKey", meth_key) cmd.Set("MinPortCount", "0") cmd.SetCollection("FeatureIdList", ["Feature1"]) cmd.Execute() cmd.MarkDelete() # Reset Config cmd = ctor.CreateCommand("ResetConfigCommand") cmd.Set("Config", CStcSystem.Instance().GetObjectHandle()) cmd.Execute() cmd.MarkDelete() sequencer = CStcSystem.Instance().GetObject("Sequencer") cmd_list = sequencer.GetObjects("Command") assert len(cmd_list) == 0 meth_handle = UnitTestUtils.get_methodology_handle(meth_key) assert meth_handle # Load the test methodology created earlier cmd = ctor.CreateCommand(PKG + ".LoadTestMethodologyCommand") meth = meth_man_utils.get_stm_methodology_from_key(meth_key) cmd.Set("StmMethodology", meth.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() cmd_list = sequencer.GetObjects("Command") assert len(cmd_list) == 3 # Strip the MethodologyGroupCommand and make the test methodology editable again cmd = ctor.CreateCommand(PKG + ".RemoveMethodologyGroupCommand") cmd.Execute() cmd.MarkDelete() # Check the sequence for cmd in sequencer.GetObjects("Command"): assert cmd.IsTypeOf(PKG + ".MethodologyGroupCommand") is False scp = cmd.GetObject("SequenceableCommandProperties", RelationType("SequenceableProperties")) assert scp is not None assert scp.Get("AllowDelete") is True assert scp.Get("AllowMove") is True assert scp.Get("AllowUngroup") is True assert scp.Get("AllowDisable") is True assert scp.Get("ShowEditor") is True # Clean up meth_man_utils.remove_active_test_relation() meth = meth_man_utils.get_stm_methodology_from_key(meth_key) cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() plLogger.LogInfo("end.test_RemoveMethodologyGroupCommand")
def d_test_publish_methodology(self, stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_publish_methodology.begin") test_name = "UnitTestMethPublishTest" meth_key = "UNITTEST_PUB" test_label_list = ["UnitTest", "Arp", "Ipv4"] min_num_ports = "2" max_num_ports = "4" port_speed_list = ["40", "100"] PORT1_LOCATION = "//10.14.16.20/2/1" PORT2_LOCATION = "//10.14.16.20/2/2" ctor = CScriptableCreator() project = CStcSystem.Instance().GetObject("Project") sequencer = CStcSystem.Instance().GetObject("Sequencer") # Delete the methodology we are about to create just in case # there was an error on a previous run. test_meth_obj = meth_man_utils.get_stm_methodology_from_key(meth_key) if test_meth_obj: # Delete installed test methodology cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Clean up empty folders (if existing) meth_man_utils.methodology_rmdir(meth_key) # Create Untagged ports port1 = ctor.Create("Port", project) port1.Set("Location", PORT1_LOCATION) port2 = ctor.Create("Port", project) port2.Set("Location", PORT2_LOCATION) cmd_name = "ArpNdStartCommand" arp_cmd = ctor.CreateCommand(cmd_name) stak_cmd_name = "Ipv4NetworkProfileGroupCommand" stak_cmd = ctor.CreateCommand(PKG_BASE + ".Ipv4NetworkProfileGroup") insert_cmd = ctor.CreateCommand("SequencerInsertCommand") insert_cmd.SetCollection("CommandList", [arp_cmd.GetObjectHandle(), stak_cmd.GetObjectHandle()]) insert_cmd.Execute() exposedConfig = ctor.Create("ExposedConfig", project) prop1 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop1, arp_cmd, cmd_name, "ArpNdOption") prop2 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop2, arp_cmd, cmd_name, "ForceArp") prop3 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop3, arp_cmd, cmd_name, "WaitForArpToFinish") prop4 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop4, stak_cmd, PKG_BASE + "." + stak_cmd_name, "DeviceCount") obj = prop1.GetObject("Scriptable", RelationType("ScriptableExposedProperty")) assert obj.GetObjectHandle() == arp_cmd.GetObjectHandle() cmd = ctor.CreateCommand(PKG + ".PublishMethodologyCommand") cmd.Set("MethodologyName", test_name) cmd.Set("MethodologyKey", meth_key) cmd.SetCollection("MethodologyLabelList", test_label_list) cmd.Set("MinPortCount", min_num_ports) cmd.Set("MaxPortCount", max_num_ports) cmd.SetCollection("PortSpeedList", port_speed_list) cmd.SetCollection("FeatureIdList", ["Feature1"]) cmd.Set("EditableParams", get_tagged_xml()) cmd.Execute() cmd.MarkDelete() sequencer = CStcSystem.Instance().GetObject("Sequencer") # Check the sequencer assert sequencer.Get("ErrorHandler") == "STOP_ON_ERROR" # Check the command sequencer cmd_list = sequencer.GetObjects("Command") assert len(cmd_list) == 3 sp_list = sequencer.GetObjects("SequenceableCommandProperties") assert len(sp_list) > 0 for cmd in cmd_list: if cmd.IsTypeOf(PKG + ".MethodologyGroupCommand"): found_tlgc = True else: sp = cmd.GetObject("SequenceableCommandProperties", RelationType("SequenceableProperties")) assert sp is not None assert sp.Get("AllowDelete") is False assert sp.Get("AllowMove") is False assert sp.Get("AllowUngroup") is False assert sp.Get("AllowDisable") is False assert sp.Get("ShowEditor") is False assert found_tlgc is True test_meth_obj = meth_man_utils.get_stm_methodology_from_key(meth_key) assert test_meth_obj # Delete installed test methodology cmd = ctor.CreateCommand(PKG + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth_obj.GetObjectHandle()) cmd.Execute() cmd.MarkDelete() plLogger.LogInfo("test_publish_methodology.end")
def test_UpdateMethodologyManagerCommand(stc): ctor = CScriptableCreator() stc_sys = CStcSystem.Instance() plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_UpdateMethodologyManagerCommand") test_pkg1 = "test_meth_1" test_pkg2 = "test_meth_2" test_pkg3 = "test_meth_3" label_list1 = ["benchmarking", "BGP", "CSMP"] label_list2 = ["OTV", "DHCPv6"] label_list3 = [] # Clean up empty folders (if existing) meth_man_utils.methodology_rmdir(test_pkg1) meth_man_utils.methodology_rmdir(test_pkg2) meth_man_utils.methodology_rmdir(test_pkg3) UnitTestUtils.create_fake_installed_test_meth(test_pkg1, label_list1) UnitTestUtils.create_fake_installed_test_meth(test_pkg2, label_list2) UnitTestUtils.create_fake_installed_test_meth(test_pkg3, label_list3) # TODO: Uncomment the test case stuff once it's fixed. # UnitTestUtils.add_fake_test_case(test_pkg1, "test_case_1") # UnitTestUtils.add_fake_test_case(test_pkg1, "test_case_2") # UnitTestUtils.add_fake_test_case(test_pkg1, "test_case_3") # UnitTestUtils.add_fake_test_case(test_pkg3, "test_case_1") # Initialize the methodology manager by calling update cmd = ctor.CreateCommand(PKG_MGR + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() meth_manager = meth_man_utils.get_meth_manager() test_meth_obj_list = meth_manager.GetObjects("StmMethodology") assert len(test_meth_obj_list) > 0 meth1 = None meth2 = None meth3 = None for test_meth_obj in test_meth_obj_list: meth_key = test_meth_obj.Get("MethodologyKey") plLogger.LogInfo("meth_name: " + test_meth_obj.Get("Name")) plLogger.LogInfo("meth_key: " + test_meth_obj.Get("MethodologyKey")) # test_case_list = [] label_list = [] if meth_key == test_pkg1: meth1 = test_meth_obj # test_case_list = ["test_case_1", "test_case_2", # "test_case_3", "original"] label_list = label_list1 elif meth_key == test_pkg2: meth2 = test_meth_obj # test_case_list = ["original"] label_list = label_list2 elif meth_key == test_pkg3: meth3 = test_meth_obj # test_case_list = ["original", "test_case_1"] label_list = label_list3 else: # No need to check this...anything here could be # from another unit test or other installed methodologies. continue # Check the path install_dir = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) exp_path = os.path.join(install_dir, meth_key) assert test_meth_obj.Get("Path") == os.path.normpath(exp_path) # Check the test cases # if len(test_case_list) > 0: # test_case_obj_list = test_meth_obj.GetObjects("StmTestCase") # for test_case_obj in test_case_obj_list: # test_case_name = test_case_obj.Get("TestCaseName") # assert test_case_name in test_case_list # test_case_list.remove(test_case_name) # assert len(test_case_list) == 0 # Check the labels exp_label_list = test_meth_obj.GetCollection("LabelList") plLogger.LogInfo("exp_label_list: " + str(exp_label_list)) plLogger.LogInfo("act_label_list: " + str(label_list)) assert len(label_list) == len(exp_label_list) if len(exp_label_list) > 0: for label in label_list: plLogger.LogInfo(" -> looking for label: " + str(label)) assert label in exp_label_list assert meth1 is not None assert meth2 is not None assert meth3 is not None # Clean up cmd = ctor.CreateCommand(PKG_MGR + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth1.GetObjectHandle()) cmd.Execute() cmd = ctor.CreateCommand(PKG_MGR + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth2.GetObjectHandle()) cmd.Execute() cmd = ctor.CreateCommand(PKG_MGR + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth3.GetObjectHandle()) cmd.Execute()
def test_import_save_delete_bll_object_update(stc): plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_import_save_delete_bll_object_update.begin") meth_name = "TestMethManUtils" meth_key = "UNITTEST_METHMANUTILS" ctor = CScriptableCreator() stc_sys = CStcSystem.Instance() project = stc_sys.GetObject("Project") # Clean up empty folder (if existing) meth_man_utils.methodology_rmdir(meth_key) stak_cmd_name = PKG + ".LoadTemplateCommand" stak_cmd = ctor.CreateCommand(stak_cmd_name) insert_cmd = ctor.CreateCommand("SequencerInsertCommand") insert_cmd.SetCollection("CommandList", [stak_cmd.GetObjectHandle()]) insert_cmd.Execute() exposedConfig = ctor.Create("ExposedConfig", project) prop1 = ctor.Create("ExposedProperty", exposedConfig) UnitTestUtils.bind(prop1, stak_cmd, stak_cmd_name, "CopiesPerParent") # Export to a distributable zip file cmd = ctor.CreateCommand(PKG_MGR + ".PublishMethodologyCommand") cmd.Set("MethodologyName", meth_name) cmd.Set("MethodologyKey", meth_key) cmd.Set("MinPortCount", "0") cmd.Execute() cmd.MarkDelete() # Reset Config cmd = ctor.CreateCommand("ResetConfigCommand") cmd.Set("Config", CStcSystem.Instance().GetObjectHandle()) cmd.Execute() cmd.MarkDelete() # Update the Methodology Manager cmd = ctor.CreateCommand(PKG_MGR + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() meth_mgr = CStcSystem.Instance().GetObject("StmMethodologyManager") assert meth_mgr is not None meth_obj = None meth_obj_list = meth_mgr.GetObjects("StmMethodology") for obj in meth_obj_list: if obj.Get("MethodologyKey") == meth_key: meth_obj = obj break assert meth_obj is not None assert 0 == len(meth_obj.GetObjects("StmTestCase")) # Add a test case new_test_case = "MyNewTestCase" cmd = ctor.CreateCommand(PKG_MGR + ".CreateTestCaseCommand") cmd.Set("TestCaseSrc", meth_obj.GetObjectHandle()) cmd.Set("TestCaseName", new_test_case) cmd.Execute() cmd.MarkDelete() # Check object update test_case_list = meth_obj.GetObjects("StmTestCase") assert len(test_case_list) == 1 found_tc1 = False tc_key = None for test_case in test_case_list: tc_name = test_case.Get("Name") if tc_name == new_test_case: found_tc1 = True tc_key = test_case.Get("TestCaseKey") assert found_tc1 assert tc_key == meth_key + "-1" # Check the path tc1_path = meth_man_utils.get_test_case_dir(meth_key, tc_key) assert os.path.exists(tc1_path) # Add a test case new_test_case2 = "MyNewTestCase2" cmd = ctor.CreateCommand(PKG_MGR + ".CreateTestCaseCommand") cmd.Set("TestCaseSrc", meth_obj.GetObjectHandle()) cmd.Set("TestCaseName", new_test_case2) cmd.Execute() cmd.MarkDelete() # Check object update test_case_list = meth_obj.GetObjects("StmTestCase") assert len(test_case_list) == 2 found_tc2 = False tc_key = None for test_case in test_case_list: tc_name = test_case.Get("Name") if tc_name == new_test_case2: found_tc2 = True tc_key = test_case.Get("TestCaseKey") assert found_tc2 assert tc_key == meth_key + "-2" # Check the path tc1_path = meth_man_utils.get_test_case_dir(meth_key, tc_key) assert os.path.exists(tc1_path) # Clean up cmd = ctor.CreateCommand(PKG_MGR + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", meth_obj.GetObjectHandle()) cmd.Execute() found_meth = meth_man_utils.get_stm_methodology_from_key(meth_key) assert found_meth is None # Test empty meth key assert meth_man_utils.get_stm_methodology_from_key("") is None
def test_find_file_across_common_paths_no_active_meth(stc): ctor = CScriptableCreator() stc_sys = CStcSystem.Instance() project = stc_sys.GetObject("Project") plLogger = PLLogger.GetLogger('methodology') plLogger.LogInfo("test_find_file_across_common_paths_no_active_meth") meth_key = "UT_FIND_FILES_TEST_ACTIVE" # Clean up empty folders (if existing) meth_man_utils.methodology_rmdir(meth_key) # Can't use unit_test_utils here to create fake methodologies # due to the custom requirements of this particular methodology. install_dir = meth_man_utils.get_methodology_home_dir() test_meth_dir = os.path.join(install_dir, meth_key) assert not os.path.exists(test_meth_dir) os.makedirs(test_meth_dir) # Add a fake sequence file seq_file = os.path.join(test_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(test_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_key, "unit test meth test case", "") data = data + UnitTestUtils.UTU_FOOTER f.write(data) f.close() # Add a fake data file data_file_name = "fake_data_file.txt" data_file_path = os.path.join(test_meth_dir, data_file_name) f = open(data_file_path, "w") f.write("Unit Test Data File (end)") f.close() # Initialize the methodology manager by calling update cmd = ctor.CreateCommand(PKG_MGR + ".UpdateTestMethodologyManagerCommand") cmd.Execute() cmd.MarkDelete() meth_manager = meth_man_utils.get_meth_manager() test_meth_obj_list = meth_manager.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.LogInfo("meth_name: " + test_meth_obj.Get("Name")) plLogger.LogInfo("meth_key: " + test_meth_obj.Get("MethodologyKey")) if act_meth_key == meth_key: test_meth = test_meth_obj break assert test_meth is not None meth_key = test_meth.Get("MethodologyKey") plLogger.LogInfo("meth_name: " + test_meth_obj.Get("Name")) plLogger.LogInfo("meth_key: " + test_meth_obj.Get("MethodologyKey")) # Check the path install_dir = os.path.join(stc_sys.GetApplicationCommonDataPath(), mgr_const.MM_TEST_METH_DIR) exp_path = os.path.join(install_dir, meth_key) assert test_meth.Get("Path") == os.path.normpath(exp_path) # Test the find_file_across_common_paths function # (no active, not loaded from file) active_tc = meth_manager.GetObject("StmTestCase", RelationType("ActiveStmTestCase")) assert active_tc is None ret_val = meth_man_utils.find_file_across_common_paths(data_file_name) assert ret_val == "" # Test the find_file_across_common_paths function # (no active, loaded from file) project.Set("ConfigurationFileName", seq_file) ret_val = meth_man_utils.find_file_across_common_paths(data_file_name) assert ret_val == os.path.normpath(data_file_path) # Clean up cmd = ctor.CreateCommand(PKG_MGR + ".DeleteMethodologyCommand") cmd.Set("StmMethodology", test_meth.GetObjectHandle()) cmd.Execute()