def test_run_txml_proc_util(stc):
plLogger = PLLogger.GetLogger("test_run_txml_proc_util")
mod_name = "unit_test_proc_funcs"
pf_dict = [get_original_input_dict()]
kv_dict = {"someKey": ["2", "4"],
"anotherKey": ["3", "9"]}
gui_kv_dict = {"weight": ["5.0", "60.0"],
"beta": ["10", "2"]}
# Create unit test proc funcs file
meth_home = meth_man_utils.get_methodology_base_dir()
plLogger.LogInfo("meth_home: " + str(meth_home))
script_dir = os.path.join(meth_home, "Scripts")
plLogger.LogInfo("script_dir: " + str(script_dir))
script_full_path = os.path.join(script_dir, mod_name + ".py")
script_comp_full_path = os.path.join(script_dir, mod_name + ".pyc")
plLogger.LogInfo("script_full_path: " + str(script_full_path))
ret_val = False
try:
if not os.path.exists(script_dir):
plLogger.LogInfo("making script dir...")
os.makedirs(script_dir)
with open(script_full_path, "w") as f:
f.write(get_ut_proc_func_file_content())
plLogger.LogInfo("wrote contents of file to " + str(script_full_path))
ret_val = RunCmd.run_txml_proc_util(pf_dict, kv_dict, gui_kv_dict)
finally:
os.remove(script_full_path)
if os.path.exists(script_comp_full_path):
os.remove(script_comp_full_path)
assert ret_val
def test_create_and_tag_ports(stc):
ctor = CScriptableCreator()
stc_sys = CStcSystem.Instance()
project = stc_sys.GetObject("Project")
tags = project.GetObject("Tags")
target1 = ctor.Create('Tag', tags)
target1.Set("Name", "EastPortGroup")
target2 = ctor.Create('Tag', tags)
target2.Set("Name", "WestPortGroup")
# Expose properties (loaded at some other step)
exposed_config = ctor.Create("ExposedConfig", project)
xp = ctor.Create("ExposedProperty", exposed_config)
xp.AddObject(target1, RelationType("ScriptableExposedProperty"))
xp.Set("EPClassId", 'Tag')
xp.Set("EPNameId", "Tag.Name.1")
xp = ctor.Create("ExposedProperty", exposed_config)
xp.AddObject(target2, RelationType("ScriptableExposedProperty"))
xp.Set("EPClassId", 'Tag')
xp.Set("EPNameId", "Tag.Name.2")
port_list = ["Tag.Name.2=//offline/2/1,//offline/2/2", "Tag.Name.1=//1.2.3.4/1/1"]
ports, offline = RunCmd.create_and_tag_ports(port_list)
assert len(ports) == 3
assert len(target2.GetObjects("Port", RelationType("UserTag", 1))) == 2
assert len(target1.GetObjects("Port", RelationType("UserTag", 1))) == 1
assert offline is True
port_list = ["Tag.Name.2=//1.2.1.2/2/1", "Tag.Name.1=//1.2.3.4/1/1"]
ports, offline = RunCmd.create_and_tag_ports(port_list)
assert len(ports) == 2
assert len(target2.GetObjects("Port", RelationType("UserTag", 1))) == 3
assert len(target1.GetObjects("Port", RelationType("UserTag", 1))) == 2
assert offline is False
return
def test_parse_txml_keys_values(stc):
plLogger = PLLogger.GetLogger("test_parse_txml_keys_values")
plLogger.LogInfo("begin")
attr1 = "Object.Property1"
attr2 = "Object.Property2"
attr3 = "Object.Property3"
attr4 = "Object.Property4"
val1 = 12
val2 = "twelve"
val3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
val4 = "12"
# Input XML
input_xml = str(
"<test>" +
"<wizard displayName=\"Unit Test Parse Key Vals\" " +
"description=\"test parsing key values in TXML\" " +
"image=\"\">" +
"<page displayName=\"stuff\" description=\"descript\" >" +
"<group displayName=\"gbox\">" +
"<property id=\"" + attr1 + "\" value=\"" + str(val1) + "\" " +
"displayName=\"attr1\" />" +
"<property id=\"" + attr2 + "\" value=\"" + str(val2) + "\" " +
"displayName=\"attr2\" />" +
"<property id=\"" + attr3 + "\" value=\"" + str(val3) + "\" " +
"displayName=\"attr3\" />" +
"</group></page>" +
"<page displayName=\"page2\" description=\"descript\">" +
"<group displayName=\"gbox\">" +
"<property id=\"" + attr4 + "\" value=\"" + str(val4) + "\" " +
"displayName=\"attr4\" />" +
"</group></page></wizard></test>")
plLogger.LogInfo("input_xml: " + str(input_xml))
root = etree.fromstring(input_xml)
assert root is not None
key_val_dict, gui_key_val_dict = RunCmd.parse_txml_keys_values(root)
assert key_val_dict is not None
assert gui_key_val_dict == {}
plLogger.LogInfo("key_val_dict: " + str(key_val_dict))
assert len(key_val_dict.keys()) == 4
# Check the keys
for kv_pair in zip([attr1, attr2, attr3, attr4],
[str(val1), str(val2), str(val3), str(val4)]):
assert kv_pair[0] in key_val_dict.keys()
assert key_val_dict[kv_pair[0]] == kv_pair[1]
def test_get_txml_proc_dict(stc):
# Input XML
input_xml = "<test>" + \
"<processingFunctions>" + \
"<processingDictionary inputDict='{\"test1\": \"blah1\"}'>" + \
"</processingDictionary>" + \
"<processingDictionary inputDict='{\"test2\": \"blah2\"}'>" + \
"</processingDictionary>" + \
"</processingFunctions>" + \
"</test>"
root = etree.fromstring(input_xml)
input_dict_list = RunCmd.get_txml_proc_dicts(root)
assert input_dict_list is not None
assert len(input_dict_list) == 2
assert input_dict_list[0]["test1"] == "blah1"
assert input_dict_list[1]["test2"] == "blah2"
def disabled_test_run_txml_proc_func_error_in_proc_func(stc):
plLogger = PLLogger.GetLogger("test_run_txml_proc_func_error")
mod_name = "unit_test_proc_funcs"
pf_key = "procFunc1"
pf_dict = {}
pf_dict["id_list"] = [pf_key]
pf_dict[pf_key] = {}
pf_dict[pf_key]["script"] = "unit_test_proc_funcs" + ".py"
pf_dict[pf_key]["entry_fn"] = "recombine_alpha_beta"
pf_dict[pf_key]["input_id_list"] = ["in_1", "in_2", "in_3"]
pf_dict[pf_key]["in_1"] = {"src_id": "alpha",
"script_var": "Alpha",
"default": None}
pf_dict[pf_key]["in_2"] = {"src_id": "beta",
"script_var": None,
"default": None}
pf_dict[pf_key]["in_3"] = {"src_id": None,
"script_var": "myConst",
"default": "5"}
pf_dict[pf_key]["output_id_list"] = ["out_1", "out_2", "out_3"]
pf_dict[pf_key]["out_1"] = {
"ep_key": "Object.AlphaTimesBeta200",
"script_var": "AlphaTimesBeta"}
pf_dict[pf_key]["out_2"] = {
"ep_key": "Object.AlphaBetaAvg12",
"script_var": "AlphaBetaAvgPlusConst"}
pf_dict[pf_key]["out_3"] = {
"ep_key": "Object.AlphaPlusBeta1",
"script_var": "AlphaPlusBeta"}
kv_dict = {"someKey": "someVal",
"anotherKey": "anotherVal"}
gui_kv_dict = {"alpha": "a",
"beta": "b"}
# Create unit test proc funcs file
meth_home = meth_man_utils.get_methodology_base_dir()
plLogger.LogInfo("meth_home: " + str(meth_home))
script_dir = os.path.join(meth_home, "Scripts")
plLogger.LogInfo("script_dir: " + str(script_dir))
script_full_path = os.path.join(script_dir, mod_name + ".py")
script_comp_full_path = os.path.join(script_dir, mod_name + ".pyc")
plLogger.LogInfo("script_full_path: " + str(script_full_path))
ret_val = False
try:
if not os.path.exists(script_dir):
plLogger.LogInfo("making script dir...")
os.makedirs(script_dir)
with open(script_full_path, "w") as f:
f.write(get_ut_proc_func_file_content())
plLogger.LogInfo("wrote contents of file to " + str(script_full_path))
ret_val = RunCmd.run_txml_proc_funcs(pf_dict, kv_dict, gui_kv_dict)
finally:
os.remove(script_full_path)
if os.path.exists(script_comp_full_path):
os.remove(script_comp_full_path)
assert not ret_val
# kv_dict should be unchanged
assert "someKey" in kv_dict.keys()
assert "anotherKey" in kv_dict.keys()
assert kv_dict["someKey"] == "someVal"
assert kv_dict["anotherKey"] == "anotherVal"
def test_parse_input_data(stc):
kv_dict = {"someKey": "someVal",
"anotherKey": ["one", "two"]}
gui_kv_dict = {"weight": 5.0,
"beta": "10"}
updated_input_dict = RunCmd.parse_input_data(get_original_input_dict(), kv_dict, gui_kv_dict)
assert updated_input_dict["id"] == "Left.CreateProtocolMix.TableData"
assert updated_input_dict["scriptFile"] == "txml_processing_functions.py"
assert updated_input_dict["entryFunction"] == "config_table_data"
customDict = {}
customDict["EnableVlan"] = "someVal"
customDict["Weight"] = 5.0
assert updated_input_dict["input"]["customDict"] == customDict
# Check interface dictionary list(ipv4 and eth)
interfaceDict = updated_input_dict["input"]["interfaceDict"]
assert len(interfaceDict) == 2
# Check IPv4 Inteface
ipv4 = {}
ipv4["ParentTagName"] = "ttIpv4If"
ipv4["ClassName"] = "Ipv4If"
ipv4["StmPropertyModifierDict"] = {}
ipv4["StmPropertyModifierDict"]["Address"] = {}
ipv4["StmPropertyModifierDict"]["Address"]["Start"] = "someVal"
ipv4["StmPropertyModifierDict"]["Address"]["Step"] = ["one", "two"]
ipv4["StmPropertyModifierDict"]["Gateway"] = {}
ipv4["StmPropertyModifierDict"]["Gateway"]["Start"] = "10"
ipv4["StmPropertyModifierDict"]["Gateway"]["Step"] = "10"
assert ipv4 in interfaceDict
# Check EthII Interface
eth = {}
eth["ParentTagName"] = "ttEthIIIf"
eth["ClassName"] = "EthIIIf"
eth["StmPropertyModifierDict"] = {}
eth["StmPropertyModifierDict"]["SourceMac"] = {}
eth["StmPropertyModifierDict"]["SourceMac"]["Start"] = "someVal"
eth["StmPropertyModifierDict"]["SourceMac"]["Step"] = ["one", "two"]
assert eth in interfaceDict
# Check protocol dictionary list(bgp and ldp)
protocolDict = updated_input_dict["input"]["protocolDict"]
assert len(protocolDict) == 2
# Check BgpRouterConfig
bgp = {}
bgp["EnableProperty"] = "someVal"
bgp["ParentTagName"] = "ttBgpRouterConfig"
bgp["ClassName"] = "BgpRouterConfig"
bgp["PropertyValueDict"] = {}
bgp["PropertyValueDict"]["IpVersion"] = "someVal"
bgp["PropertyValueDict"]["EnableBfd"] = ["one", "two"]
bgp["StmPropertyModifierDict"] = {}
bgp["StmPropertyModifierDict"]["AsNum"] = {}
bgp["StmPropertyModifierDict"]["AsNum"]["Start"] = "10"
bgp["StmPropertyModifierDict"]["AsNum"]["Step"] = "1"
bgp["StmPropertyModifierDict"]["DutAsNum"] = {}
bgp["StmPropertyModifierDict"]["DutAsNum"]["Start"] = "someVal"
bgp["StmPropertyModifierDict"]["DutAsNum"]["Step"] = "1"
assert bgp in protocolDict
# Check LdpRouterConfig
ldp = {}
ldp["EnableProperty"] = "someVal"
ldp["ParentTagName"] = "ttLdpRouterConfig"
ldp["ClassName"] = "LdpRouterConfig"
ldp["PropertyValueDict"] = {}
ldp["PropertyValueDict"]["HelloVersion"] = "someVal"
ldp["PropertyValueDict"]["EnableBfd"] = "10"
assert ldp in protocolDict
# Check output data
output = {}
output["scriptVarName"] = "TableData"
output["epKey"] = "TestMethodologyCreateProtocolMixCommand3TableData"
assert updated_input_dict["output"][0] == output
def test_parse_proc_funcs(stc):
plLogger = PLLogger.GetLogger("test_parse_proc_funcs")
pf_id = "procFunc1"
ep_key1 = "Object.AlphaPlusBeta1"
ep_key2 = "Object.AlphaTimesBeta200"
ep_key3 = "Object.AlphaBetaAvg12"
# Input XML
input_xml = "<test>" + \
"<processingFunctions>" + \
"<processingFunction id=\"" + pf_id + "\" " + \
"scriptFile=\"utProcFuncScript.py\" " + \
"entryFunction=\"recombine_alpha_beta\">" + \
"<input srcId=\"alpha\" scriptVarName=\"Alpha\" />" + \
"<input srcId=\"beta\" />" + \
"<input scriptVarName=\"myConst\" " + \
"default=\"5\" />" + \
"<output epKey=\"" + ep_key1 + "\" " + \
"scriptVarName=\"AlphaPlusBeta\" />" + \
"<output scriptVarName=\"AlphaTimesBeta\" " + \
"epKey=\"" + ep_key2 + "\" />" + \
"<output epKey=\"" + ep_key3 + "\" " + \
"scriptVarName=\"AlphaBetaAvg\" />" + \
"</processingFunction>" + \
"</processingFunctions>" + \
"</test>"
root = etree.fromstring(input_xml)
pf_dict = RunCmd.parse_txml_proc_funcs(root)
plLogger.LogInfo("pf_dict: " + str(pf_dict))
assert pf_dict is not None
assert "id_list" in pf_dict.keys()
assert pf_id in pf_dict.keys()
assert "script" in pf_dict[pf_id].keys()
assert pf_dict[pf_id]["script"] == "utProcFuncScript.py"
assert "entry_fn" in pf_dict[pf_id].keys()
assert pf_dict[pf_id]["entry_fn"] == "recombine_alpha_beta"
assert "input_id_list" in pf_dict[pf_id].keys()
assert len(pf_dict[pf_id]["input_id_list"]) == 3
assert "in_1" in pf_dict[pf_id]["input_id_list"]
assert "in_2" in pf_dict[pf_id]["input_id_list"]
assert "in_3" in pf_dict[pf_id]["input_id_list"]
assert "src_id" in pf_dict[pf_id]["in_1"].keys()
assert pf_dict[pf_id]["in_1"]["src_id"] == "alpha"
assert "script_var" in pf_dict[pf_id]["in_1"].keys()
assert pf_dict[pf_id]["in_1"]["script_var"] == "Alpha"
assert "default" in pf_dict[pf_id]["in_1"].keys()
assert pf_dict[pf_id]["in_1"]["default"] is None
assert "src_id" in pf_dict[pf_id]["in_2"].keys()
assert pf_dict[pf_id]["in_2"]["src_id"] == "beta"
assert "script_var" in pf_dict[pf_id]["in_2"].keys()
assert pf_dict[pf_id]["in_2"]["script_var"] is None
assert "default" in pf_dict[pf_id]["in_2"].keys()
assert pf_dict[pf_id]["in_2"]["default"] is None
assert "src_id" in pf_dict[pf_id]["in_3"].keys()
assert pf_dict[pf_id]["in_3"]["src_id"] is None
assert "script_var" in pf_dict[pf_id]["in_3"].keys()
assert pf_dict[pf_id]["in_3"]["script_var"] == "myConst"
assert "default" in pf_dict[pf_id]["in_3"].keys()
assert pf_dict[pf_id]["in_3"]["default"] == "5"
assert "output_id_list" in pf_dict[pf_id].keys()
assert len(pf_dict[pf_id]["output_id_list"]) == 3
assert "out_1" in pf_dict[pf_id]["output_id_list"]
assert "out_2" in pf_dict[pf_id]["output_id_list"]
assert "out_3" in pf_dict[pf_id]["output_id_list"]
assert "ep_key" in pf_dict[pf_id]["out_1"].keys()
assert pf_dict[pf_id]["out_1"]["ep_key"] == ep_key1
assert "script_var" in pf_dict[pf_id]["out_1"].keys()
assert pf_dict[pf_id]["out_1"]["script_var"] == "AlphaPlusBeta"
assert "ep_key" in pf_dict[pf_id]["out_2"].keys()
assert pf_dict[pf_id]["out_2"]["ep_key"] == ep_key2
assert "script_var" in pf_dict[pf_id]["out_2"].keys()
assert pf_dict[pf_id]["out_2"]["script_var"] == "AlphaTimesBeta"
assert "ep_key" in pf_dict[pf_id]["out_3"].keys()
assert pf_dict[pf_id]["out_3"]["ep_key"] == ep_key3
assert "script_var" in pf_dict[pf_id]["out_3"].keys()
assert pf_dict[pf_id]["out_3"]["script_var"] == "AlphaBetaAvg"
def test_parse_port_groups():
plLogger = PLLogger.GetLogger("test_parse_port_groups")
plLogger.LogInfo("begin")
ctor = CScriptableCreator()
stc_sys = CStcSystem.Instance()
# project = stc_sys.GetObject("Project")
# sequencer = CStcSystem.Instance().GetObject("Sequencer")
# hnd_reg = CHandleRegistry.Instance()
common_data_path = stc_sys.GetApplicationCommonDataPath()
meth_name = "test_RunStmTestCaseCommand_test_parse_port_groups"
test_name = "test_parse_port_groups"
# 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
# Create a fake TXML file
txml_content = get_test_txml()
txml_file = os.path.join(test_dir, mgr_const.MM_META_FILE_NAME)
f = open(txml_file, "w")
f.write(txml_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_case = ctor.Create("StmTestCase", test_meth)
test_case.Set("Path", txml_file)
root = RunCmd.get_txml_file_root(txml_file)
assert root is not None
port_group_dict = RunCmd.parse_txml_port_groups(root)
assert port_group_dict is not None
assert len(port_group_dict.keys()) == 2
assert "Tag.Name.1632" in port_group_dict.keys()
assert "Tag.Name.1633" in port_group_dict.keys()
assert len(port_group_dict["Tag.Name.1632"]) == 2
assert "//10.14.16.27/1/1" in port_group_dict["Tag.Name.1632"]
assert "//10.14.16.27/1/2" in port_group_dict["Tag.Name.1632"]
assert len(port_group_dict["Tag.Name.1633"]) == 2
assert "//10.14.16.27/2/1" in port_group_dict["Tag.Name.1633"]
assert "//10.14.16.27/2/2" in port_group_dict["Tag.Name.1633"]
# Test the list constructor for the MethdologyGroupCommand
prop_val = RunCmd.build_port_group_list(port_group_dict)
plLogger.LogInfo("key_val_list: " + str(prop_val))
assert len(prop_val) == 2
assert "Tag.Name.1632=//10.14.16.27/1/1,//10.14.16.27/1/2" in prop_val
assert "Tag.Name.1633=//10.14.16.27/2/1,//10.14.16.27/2/2" in prop_val
# 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_parse_txml_table_keys_values(stc):
plLogger = PLLogger.GetLogger("test_parse_table_txml_keys_values")
plLogger.LogInfo("begin")
attr1 = "Object.Property1"
attr2 = "Object.Property2"
attr3 = "Object.Property3"
attr4 = "Object.Property4"
val1 = 12
val2 = "twelve"
val3 = True
val4 = "331"
# Input XML
input_xml = str(
"<test>" +
"<wizard displayName=\"Unit Test Parse Key Vals\" " +
"description=\"test parsing key values in TXML\" " +
"image=\"\">" +
"<page displayName=\"stuff\" description=\"descript\" >" +
"<group displayName=\"gbox\">" +
"<property id=\"" + attr1 + "\" value=\"" + str(val1) + "\" " +
"displayName=\"attr1\">" +
"<data>13</data>" +
"<data>14</data>" +
"<data>15.5</data>" +
"</property>" +
"<property id=\"" + attr2 + "\" value=\"" + str(val2) + "\" " +
"displayName=\"attr2\">" +
"<data>thirteen</data>" +
"<data>fourteen</data>" +
"<data>fifteen and a half</data>" +
"</property>" +
"<property id=\"" + attr3 + "\" value=\"" + str(val3) + "\" " +
"displayName=\"attr3\">" +
"<data>True</data>" +
"<data>False</data>" +
"<data>True</data>" +
"</property>" +
"<property id=\"" + attr4 + "\" value=\"" + str(val4) + "\" " +
"displayName=\"attr4\" />" +
"</group></page></wizard></test>")
plLogger.LogInfo("input_xml: " + str(input_xml))
root = etree.fromstring(input_xml)
assert root is not None
key_val_dict, gui_key_val_dict = RunCmd.parse_txml_keys_values(root)
assert key_val_dict is not None
assert gui_key_val_dict == {}
plLogger.LogInfo("key_val_dict: " + str(key_val_dict))
assert len(key_val_dict.keys()) == 4
# Check the key-value pairs (single property)
assert attr4 in key_val_dict.keys()
assert key_val_dict[attr4] == val4
# Check the key-value pairs (table)
for exp_kv_pair in zip([attr1, attr2, attr3],
[["13", "14", "15.5"],
["thirteen", "fourteen",
"fifteen and a half"],
["True", "False", "True"]]):
assert exp_kv_pair[0] in key_val_dict.keys()
assert key_val_dict[exp_kv_pair[0]] == exp_kv_pair[1]
