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 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 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 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 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
