def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
vm_create_option = test_util.VmOption()
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_actions = [test_state.TestAction.sg_rule_operations]*2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
Will doing random test operations, including vm create/stop/start/reboot
/destroy, volume create/attach/detach/delete. It doesn't include SG
VIP and snapshots operations. If reach max 4 coexisting running vm,
testing will success and quit.
''')
target_running_vm = 4
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.sg_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.snapshot_actions)
priority_actions = test_state.TestAction.volume_actions * 4
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
print "test_dict: %s" % test_dict
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('Round %s finished. Begin status checking.' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(
os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
if os.environ.get('ZSTACK_SIMULATOR') != "yes":
utility_vm.check()
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
vm_create_option = test_util.VmOption()
#image has to use network test image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
priority_actions = [test_state.TestAction.sg_rule_operations]*2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.snapshot_actions)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
global curr_deploy_conf
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up cluster1
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name=cluster1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_util.test_dsc('delete cluster')
cluster_ops.delete_cluster(cluster1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
cluster_ops.add_cluster_resource(curr_deploy_conf, cluster1_name)
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name=cluster1_name)[0]
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm_creation_option.set_l3_uuids([])
vm1.start()
vm2.start()
vm3.start()
vm4.start()
test_lib.lib_robot_status_check(test_obj_dict)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Cluster Test Success')
def test():
global host_config
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up host1
host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_host_uuid(host1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
host_config.set_name(host1_name)
host_config.set_cluster_uuid(host1.clusterUuid)
host_config.set_management_ip(host1.managementIp)
host_config.set_username(os.environ.get('hostUsername'))
host_config.set_password(os.environ.get('hostPassword'))
test_util.test_dsc('delete host')
host_ops.delete_host(host1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm2.update()
vm2.set_state(vm_header.STOPPED)
test_lib.lib_robot_status_check(test_obj_dict)
test_util.test_dsc('start vm on other host')
vm1.start()
vm2.start()
test_lib.lib_robot_status_check(test_obj_dict)
host_ops.add_kvm_host(host_config)
host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0]
#vm_creation_option.set_host_uuid(host1.uuid)
#vm_creation_option.set_l3_uuids([])
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Host Test Success')
def test():
global curr_deploy_conf
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up cluster1
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_util.test_dsc('delete cluster')
cluster_ops.delete_cluster(cluster1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
cluster_ops.add_cluster_resource(curr_deploy_conf, cluster1_name)
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0]
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm_creation_option.set_l3_uuids([])
vm1.start()
vm2.start()
vm3.start()
vm4.start()
test_lib.lib_robot_status_check(test_obj_dict)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Cluster Test Success')
def test():
global host_config
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up host1
host1 = res_ops.get_resource(res_ops.HOST, name = host1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_host_uuid(host1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
host_config.set_name(host1_name)
host_config.set_cluster_uuid(host1.clusterUuid)
host_config.set_management_ip(host1.managementIp)
host_config.set_username(os.environ.get('hostUsername'))
host_config.set_password(os.environ.get('hostPassword'))
test_util.test_dsc('delete host')
host_ops.delete_host(host1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm2.update()
vm2.set_state(vm_header.STOPPED)
test_lib.lib_robot_status_check(test_obj_dict)
test_util.test_dsc('start vm on other host')
vm1.start()
vm2.start()
test_lib.lib_robot_status_check(test_obj_dict)
host_ops.add_kvm_host(host_config)
host1 = res_ops.get_resource(res_ops.HOST, name = host1_name)[0]
#vm_creation_option.set_host_uuid(host1.uuid)
#vm_creation_option.set_l3_uuids([])
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Host Test Success')
def test():
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
initial_formation = flavor['initial_formation']
if flavor.has_key('config'):
config = flavor['config']
else:
config = None
path_list = flavor['path_list']
test_util.test_dsc('''Will mainly doing random test for all kinds of snapshot operations. VM, Volume and Image operations will also be tested. If reach 1 hour successful running condition, testing will success and quit. SG actions, and VIP actions are removed in this robot test.
VM resources: a special Utility vm is required to do volume attach/detach operation.
''')
test_util.test_dsc('Constant Path Test Begin.')
robot_test_obj = test_util.Robot_Test_Object()
if not config:
config = default_config
robot_test_obj.set_config(config)
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_initial_formation(initial_formation)
list_group_dict = {'VM_OPS':[[TestAction.stop_vm, "vm1"], [TestAction.reinit_vm, "vm1"], [TestAction.start_vm, "vm1"], [TestAction.suspend_vm, 'vm1'], [TestAction.resume_vm, 'vm1'], [TestAction.reboot_vm, 'vm1'], [TestAction.destroy_vm, 'vm1']]}
robot_test_obj.set_constant_path_list_group_dict(list_group_dict)
robot_test_obj.set_constant_path_list(path_list)
print "constant_path_list=%s" %(str(robot_test_obj.get_constant_path_list()))
print "constant_path_list_group_dict=%s" %(str(robot_test_obj.get_constant_path_list_group_dict()))
test_lib.lib_robot_create_initial_formation(robot_test_obj)
test_lib.lib_robot_create_utility_vm(robot_test_obj)
rounds = 1
current_time = time.time()
timeout_time = current_time + 7200
while time.time() <= timeout_time:
print "DEBUG:",test_dict
all_volume_list = test_dict.get_all_volume_list()
for volume in all_volume_list:
sp = test_dict.get_volume_snapshot(volume.get_volume().uuid)
sp_list = sp.get_snapshot_list()
for i in sp_list:
print "spspspsp, %s,%s" % (i.get_snapshot().uuid, i.md5sum)
print "vovovovo, %s,%s" % (volume.get_volume().uuid, volume.md5sum)
test_util.test_dsc('New round %s starts:' % rounds)
test_lib.lib_robot_constant_path_operation(robot_test_obj, set_robot=False)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_logger("Remaining constant path: %s" % robot_test_obj.get_constant_path_list())
if not robot_test_obj.get_constant_path_list():
test_util.test_dsc('Reach test pass exit criterial: Required path executed %s' % (path_list))
break
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
test_util.test_dsc('''Will mainly doing random test for all kinds of snapshot operations. VM, Volume and Image operations will also be tested. If reach 1 hour successful running condition, testing will success and quit. SG actions, and VIP actions are removed in this robot test.
VM resources: a special Utility vm is required to do volume attach/detach operation.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
if os.environ.get('ZSTACK_SIMULATOR') != "yes":
utility_vm.check()
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions + \
[ test_state.TestAction.create_volume ])
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
robot_test_obj.set_random_type(action_select.fair_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial: 1 hour.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
test_util.test_dsc('''
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
if os.environ.get('ZSTACK_SIMULATOR') != "yes":
utility_vm.check()
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions + \
[test_state.TestAction.create_volume])
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
test_util.test_dsc('''
will only do vm operations robot testing. It will use pathselector to do
full path coverage testing.
''')
vm_create_option = test_util.VmOption()
test_util.test_dsc(
'Random Test Begin. Test target: 24hour full path test.')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_actions = [test_state.TestAction.sg_rule_operations] * 2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
robot_test_obj.set_random_type(action_select.path_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600 * 24
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('VM Ops Full Path Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
vm_create_option = test_util.VmOption()
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_actions = [test_state.TestAction.sg_rule_operations] * 2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
will only do vm operations robot testing. It will use pathselector to do
full path coverage testing.
''')
vm_create_option = test_util.VmOption()
test_util.test_dsc('Random Test Begin. Test target: 1hour full path test.')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_actions = [test_state.TestAction.sg_rule_operations]*2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
robot_test_obj.set_random_type(action_select.path_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('VM Ops Full Path Test Success')
def test():
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
global curr_deploy_conf
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up zone1
zone1 = res_ops.get_resource(res_ops.ZONE, name=zone1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_zone_uuid(zone1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
zone_ops.delete_zone(zone1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
zone_ops.add_zone_resource(curr_deploy_conf, zone1_name)
zone1 = res_ops.get_resource(res_ops.ZONE, name=zone1_name)[0]
vm_creation_option.set_zone_uuid(zone1.uuid)
vm_creation_option.set_l3_uuids([])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_lib.lib_robot_status_check(test_obj_dict)
#time.sleep(5)
#vm.check()
#vm.destroy()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Zone Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
vm_create_option = test_util.VmOption()
#image has to use network test image, as it needs to do port checking
vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
priority_actions = [test_state.TestAction.sg_rule_operations] * 2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.snapshot_actions)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
utility_vm.check()
vm_create_option = test_util.VmOption()
#image has to use network test image, as it needs to do port checking
vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
#Add 3 times sg_rule_operations, vip_operations and 2 times vm creation
priority_actions = [test_state.TestAction.sg_rule_operations] * 2 + \
[test_state.TestAction.vip_operations] * 2 + \
[test_state.TestAction.create_vm]
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
public_l3 = test_lib.lib_find_vr_pub_nic(vrs[0]).l3NetworkUuid
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
robot_test_obj.set_random_type(action_select.weight_fair_strategy)
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
rounds = 1
current_time = time.time()
timeout_time = current_time + 7200
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('Round %s finished. Begin status checking.' %
rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
global ps_inv
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
zone1_name = os.environ.get('zoneName1')
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
#pick up primary storage 1 and set system tag for instance offering.
zone_name = os.environ.get('zoneName1')
zone_uuid = res_ops.get_resource(res_ops.ZONE, name = zone_name)[0].uuid
cond = res_ops.gen_query_conditions('zoneUuid', '=', zone_uuid)
ps_inv = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0]
if ps_inv.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
elif ps_inv.type == inventory.CEPH_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('cephPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_detach_ps')
vm_creation_option.set_zone_uuid(zone1.uuid)
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_inv.uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
volume1 = test_stub.create_volume()
test_obj_dict.add_volume(volume1)
volume1.attach(vm1)
test_util.test_dsc("Delete Primary Storage")
#need to delete tag as well
tag_ops.delete_tag(tag.uuid)
ps_ops.delete_primary_storage(ps_inv.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
test_obj_dict.rm_volume(volume1)
volume1.update()
test_lib.lib_robot_status_check(test_obj_dict)
test_util.test_dsc("Recover Primary Storage")
test_stub.recover_ps(ps_inv)
test_lib.lib_robot_status_check(test_obj_dict)
#update tag
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_inv.uuid)
test_util.test_dsc("Create new VM and Volume")
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
volume2 = test_stub.create_volume()
test_obj_dict.add_volume(volume2)
volume2.attach(vm2)
vm2.check()
volume2.check()
tag_ops.delete_tag(tag.uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test deleting primary storage Success')
def test():
test_util.test_dsc('''
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
public_l3 = test_lib.lib_find_vr_pub_nic(vrs[0]).l3NetworkUuid
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
priority_actions = test_state.TestAction.vip_actions * 2 + \
[test_state.TestAction.vip_operations] * 2
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_random_type(action_select.weight_fair_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
if len(vrs) < 1:
test_util.test_skip('VR is required for testing')
public_l3 = test_lib.lib_find_vr_pub_nic(vrs[0]).l3NetworkUuid
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
priority_actions = test_state.TestAction.vip_actions * 4
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.sg_actions \
+ test_state.TestAction.snapshot_actions)
robot_test_obj.set_public_l3(public_l3)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
utility_vm.check()
vm_create_option = test_util.VmOption()
#image has to use network test image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
#Add 3 times sg_rule_operations, vip_operations and 2 times vm creation
priority_actions = [test_state.TestAction.sg_rule_operations] * 2 + \
[test_state.TestAction.vip_operations] * 2 + \
[test_state.TestAction.create_vm]
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
public_l3 = test_lib.lib_find_vr_pub_nic(vrs[0]).l3NetworkUuid
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
robot_test_obj.set_random_type(action_select.weight_fair_strategy)
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
rounds = 1
current_time = time.time()
timeout_time = current_time + 7200
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('Round %s finished. Begin status checking.' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
test_util.test_dsc(
'''Will mainly doing random test for all kinds of snapshot operations. VM, Volume and Image operations will also be tested. If reach 1 hour successful running condition, testing will success and quit. SG actions, and VIP actions are removed in this robot test.
VM resources: a special Utility vm is required to do volume attach/detach operation.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(
os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(
test_lib.lib_get_image_by_name(
img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
utility_vm.check()
test_util.test_dsc(
'Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).'
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
robot_test_obj.set_random_type(action_select.fair_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' %
rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc(
'===============Round %s finished. Begin status checking.================'
% rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial: 1 hour.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
global curr_deploy_conf
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up zone1
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_zone_uuid(zone1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
zone_ops.delete_zone(zone1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
zone_ops.add_zone_resource(curr_deploy_conf, zone1_name)
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
vm_creation_option.set_zone_uuid(zone1.uuid)
vm_creation_option.set_l3_uuids([])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_lib.lib_robot_status_check(test_obj_dict)
#time.sleep(5)
#vm.check()
#vm.destroy()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Zone Test Success')
def test():
test_util.test_dsc(
"""
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
"""
)
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
# create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
# we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
# VIP testing need 3 VRs
if vr_num > 2:
break
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
public_l3 = test_lib.lib_find_vr_pub_nic(vrs[0]).l3NetworkUuid
vm_create_option = test_util.VmOption()
# image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get("imageName_net")).uuid)
priority_actions = test_state.TestAction.vip_actions * 2 + [test_state.TestAction.vip_operations] * 2
test_util.test_dsc(
"Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.)."
)
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(
test_state.TestAction.volume_actions
+ test_state.TestAction.image_actions
+ test_state.TestAction.sg_actions
+ test_state.TestAction.snapshot_actions
)
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_random_type(action_select.weight_fair_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc("New round %s starts: random operation pickup." % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc("===============Round %s finished. Begin status checking.================" % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc("Reach test pass exit criterial.")
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass("Create random VM Test Success")
