def test(): global curr_deploy_conf global l2_name2 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 l3 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name1)[0] l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0] l2_2 = res_ops.get_resource(res_ops.L2_NETWORK, \ uuid = l3_2.l2NetworkUuid)[0] l2_name2 = l2_2.name 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_l3_uuids([l3_1.uuid, l3_2.uuid]) cluster1_name = os.environ.get('clusterName2') cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0] vm_creation_option.set_cluster_uuid(cluster1.uuid) vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) test_util.test_dsc('Delete l2_2') net_ops.delete_l2(l2_2.uuid) test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) vm1.update() vm1.set_state(vm_header.STOPPED) vm1.check() test_util.test_dsc('start vm again. vm should remove the deleted l2') vm1.start() net_ops.add_l2_resource(curr_deploy_conf, l2_name = l2_name2) #update l3_2, since it is readded. l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0] vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid]) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) #check vm1 vm2 status. vm1.check() if not len(vm1.get_vm().vmNics) == 1: test_util.test_fail('vm1 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) vm2.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L2 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(): global vm vm = test_lib.lib_create_vm() vm.check() vm.destroy() test_util.test_pass("Create random VM Test Success")
def test(): global vm create_vm_option = test_util.VmOption() create_vm_option.set_rootVolume_systemTags(["volumeProvisioningStrategy::ThinProvisioning"]) create_vm_option.set_name('test_resize_vm_root_volume') vm = test_lib.lib_create_vm(create_vm_option) vm.check() vm.stop() vm.check() vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size volume_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid set_size = 1024*1024*1024*5 vol_ops.resize_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size if set_size != vol_size_after: test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after) vm.start() set_size = 1024*1024*1024*6 vol_ops.resize_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size if set_size != vol_size_after: test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after) vm.destroy() test_util.test_pass('Resize VM Test Success')
def test(): global vm vm = test_lib.lib_create_vm() vm.check() vm.destroy() 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(): create_vm_option = test_util.VmOption() create_vm_option.set_name('test_create_ThinProvisioning_vm') create_vm_option.set_rootVolume_systemTags(["volumeProvisioningStrategy::ThinProvisioning"]) vm_1 = test_lib.lib_create_vm(create_vm_option) vm_1.check() test_obj_dict.add_vm(vm_1) vm_1.destroy() test_util.test_pass('Create VM Test Success')
def test(): global curr_deploy_conf global l3_1 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name1)[0] 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 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_l3_uuids([l3_1.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) test_util.test_dsc('Delete l3_1') net_ops.delete_l3(l3_1.uuid) #Since 0.8, delete L3 won't delete VM. It will just detach L3 nic. #test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED) #test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED) #vm1.set_state(vm_header.DESTROYED) #vm2.set_state(vm_header.DESTROYED) vm1.check() vm2.check() net_ops.add_l3_resource(curr_deploy_conf, l3_name=l3_1.name) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L3 Test 2 Success')
def test(): global vm vm = test_lib.lib_create_vm() #vm = test_stub.create_vr_vm('migrate_vm', 'imageName_s', 'l3VlanNetwork2') vm.check() test_stub.migrate_vm_to_random_host(vm) vm.check() vm.destroy() test_util.test_pass('Migrate VM Test Success')
def test(): global curr_deploy_conf global l3_1 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name1)[0] 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 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_l3_uuids([l3_1.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) test_util.test_dsc('Delete l3_1') net_ops.delete_l3(l3_1.uuid) #Since 0.8, delete L3 won't delete VM. It will just detach L3 nic. #test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED) #test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED) #vm1.set_state(vm_header.DESTROYED) #vm2.set_state(vm_header.DESTROYED) vm1.check() vm2.check() net_ops.add_l3_resource(curr_deploy_conf, l3_name = l3_1.name) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L3 Test 2 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(): global image_obj 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_inv = test_lib.lib_get_image_by_name(image_name) image_uuid = image_inv.uuid image_crt_opt = test_util.ImageOption() image_crt_opt.set_name(image_inv.name) image_crt_opt.set_url(image_inv.url) image_crt_opt.set_format(image_inv.format) image_crt_opt.set_system(image_inv.system) image_crt_opt.set_mediaType(image_inv.mediaType) image_crt_opt.set_guest_os_type(image_inv.type) bss = image_inv.backupStorageRefs bss_uuids = [] for bs in bss: bss_uuids.append(bs.backupStorageUuid) image_crt_opt.set_backup_storage_uuid_list(bss_uuids) image_obj.set_creation_option(image_crt_opt) 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') vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) test_util.test_dsc('delete image') img_ops.delete_image(image_uuid) #in bug, when destroy vm after delete related image, destroy vm will fail test_util.test_dsc('destroy vm') vm1.destroy() test_obj_dict.rm_vm(vm1) test_util.test_dsc('add image back') image_obj.add_root_volume_template() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete Image Test Success')
def test(): global image_obj 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_inv = test_lib.lib_get_image_by_name(image_name) image_uuid = image_inv.uuid image_crt_opt = test_util.ImageOption() image_crt_opt.set_name(image_inv.name) image_crt_opt.set_url(image_inv.url) image_crt_opt.set_format(image_inv.format) image_crt_opt.set_system(image_inv.system) image_crt_opt.set_mediaType(image_inv.mediaType) image_crt_opt.set_guest_os_type(image_inv.type) bss = image_inv.backupStorageRefs bss_uuids = [] for bs in bss: bss_uuids.append(bs.backupStorageUuid) image_crt_opt.set_backup_storage_uuid_list(bss_uuids) image_obj.set_creation_option(image_crt_opt) 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') vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) test_util.test_dsc('delete image') img_ops.delete_image(image_uuid) #in bug, when destroy vm after delete related image, destroy vm will fail test_util.test_dsc('destroy vm') vm1.destroy() test_obj_dict.rm_vm(vm1) test_util.test_dsc('add image back') image_obj.add_root_volume_template() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete Image Test Success')
def test(): global test_obj_dict volume_creation_option = test_util.VolumeOption() test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_system_tags(["volumeProvisioningStrategy::ThinProvisioning", "capability::virtio-scsi"]) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_uuid = volume.volume.uuid vol_size = volume.volume.size image_name = os.environ.get('imageName_net') l3_name = os.environ.get('l3VlanNetworkName1') create_vm_option = test_util.VmOption() create_vm_option.set_name('test_resize_vm_root_volume') vm = test_lib.lib_create_vm(create_vm_option) # vm = test_stub.create_vm("test_resize_vm", image_name, l3_name) vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) vm.stop() vm.check() set_size = 1024*1024*1024*5 vol_ops.resize_data_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_data_volumes(vm.get_vm())[0].size if set_size != vol_size_after: test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) vm.start() vm.check() set_size = 1024*1024*1024*6 vol_ops.resize_data_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_data_volumes(vm.get_vm())[0].size if set_size != vol_size_after: test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Resize Data Volume Test Success')
def test(): test_util.test_dsc('Create original vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Construct volume obj.') vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) #root_volume = zstack_vol_header.ZstackTestVolume() #root_volume.set_volume(vm_root_volume_inv) #root_volume.set_target_vm(vm) #root_volume.set_state(vol_header.ATTACHED) root_volume_uuid = vm_root_volume_inv.uuid root_image_uuid = vm_root_volume_inv.rootImageUuid vm_img_inv = test_lib.lib_get_image_by_uuid(root_image_uuid) test_util.test_dsc('Stop vm before create snapshot.') vm.stop() test_util.test_dsc('create snapshot') #snapshots = zstack_sp_header.ZstackVolumeSnapshot() #snapshots.set_target_volume(root_volume) #test_obj_dict.add_volume_snapshot(snapshots) snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm1) snapshots.create_snapshot('create_root_snapshot1') snapshot1 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot2') snapshot2 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot3') snapshot3 = snapshots.get_current_snapshot() test_util.test_dsc('delete snapshot3 and create image tempalte from root') snapshots.delete_snapshot(snapshot3) image_option = test_util.ImageOption() image_option.set_name('creating_image_from_root_volume_after_creating_sp') image_option.set_guest_os_type(vm_img_inv.guestOsType) image_option.set_bits(vm_img_inv.bits) image_option.set_root_volume_uuid(root_volume_uuid) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm( vm.get_vm()) bs_uuid_list = [] for bs in backup_storage_list: bs_uuid_list.append(bs.uuid) image_option.set_backup_storage_uuid_list(bs_uuid_list) test_util.test_dsc('create image template from root volume') image2 = zstack_img_header.ZstackTestImage() image2.set_creation_option(image_option) image2.create() test_obj_dict.add_image(image2) image2.check() image2_uuid = image2.get_image().uuid test_util.test_dsc('create vm2 with new created template and check') vm_creation_option = vm.get_creation_option() vm_creation_option.set_image_uuid(image2_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm2.destroy() test_obj_dict.rm_vm(vm2) test_util.test_dsc('create snapshot4 and finally delete all snapshots') snapshots.create_snapshot('create_snapshot4') snapshot4 = snapshots.get_current_snapshot() snapshot4.backup() snapshots.check() snapshots.delete() test_obj_dict.rm_volume_snapshot(snapshots) test_util.test_dsc('create image template2 from root volume') image3 = zstack_img_header.ZstackTestImage() image3.set_creation_option(image_option) image3.create() test_obj_dict.add_image(image3) image3.check() image3_uuid = image3.get_image().uuid test_util.test_dsc('create vm3 with new created template and check') vm_creation_option.set_image_uuid(image3_uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() vm3.destroy() test_obj_dict.rm_vm(vm3) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass( 'Create image from root volume with creating/destroying Snapshot 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(): 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_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid #pick up host1 host1_name = os.environ.get('hostName') host1 = res_ops.get_resource(res_ops.HOST, name = host1_name)[0] host3_name = os.environ.get('hostName3') host3 = res_ops.get_resource(res_ops.HOST, name = host3_name)[0] cond = res_ops.gen_query_conditions('clusterUuid', '=', host1.clusterUuid) cluster_hosts = res_ops.query_resource(res_ops.HOST, cond) if not len(cluster_hosts) > 1: test_util.test_skip('Skip test, since [cluster:] %s did not include more than 1 host' % host1.clusterUuid) for host in cluster_hosts: if host.uuid != host1.uuid: host2 = host 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) 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) vr_vm_inv = test_lib.lib_find_vr_by_vm(vm1.get_vm())[0] vr_host_uuid = vr_vm_inv.hostUuid #migrate vr to host3. if vr_host_uuid != host3.uuid: vm_ops.migrate_vm(vr_vm_inv.uuid, host3.uuid) host_config.set_cluster_uuid(host3.clusterUuid) host_config.set_username(os.environ.get('hostUsername')) host_config.set_password(os.environ.get('hostPassword')) host_config.set_name(host3_name) host_config.set_management_ip(host3.managementIp) target_host_uuid = host3.uuid test_util.test_dsc("Delete VR VM's host. VR should be migrated to Cluster1") host_ops.delete_host(target_host_uuid) vm1.check() #using the same L3 to create VM2 to check if VR is working well. vm_creation_option.set_host_uuid(None) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() host_ops.add_kvm_host(host_config) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test VR migration when deleting Host is 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('Create original vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Construct volume obj.') vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) #root_volume = zstack_vol_header.ZstackTestVolume() #root_volume.set_volume(vm_root_volume_inv) #root_volume.set_target_vm(vm) #root_volume.set_state(vol_header.ATTACHED) root_volume_uuid = vm_root_volume_inv.uuid root_image_uuid = vm_root_volume_inv.rootImageUuid vm_img_inv = test_lib.lib_get_image_by_uuid(root_image_uuid) test_util.test_dsc('Stop vm before create snapshot.') vm.stop() test_util.test_dsc('create snapshot') #snapshots = zstack_sp_header.ZstackVolumeSnapshot() #snapshots.set_target_volume(root_volume) #test_obj_dict.add_volume_snapshot(snapshots) snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm1) snapshots.create_snapshot('create_root_snapshot1') snapshot1 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot2') snapshot2 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot3') snapshot3 = snapshots.get_current_snapshot() test_util.test_dsc('delete snapshot3 and create image tempalte from root') snapshots.delete_snapshot(snapshot3) image_option = test_util.ImageOption() image_option.set_name('creating_image_from_root_volume_after_creating_sp') image_option.set_guest_os_type(vm_img_inv.guestOsType) image_option.set_bits(vm_img_inv.bits) image_option.set_root_volume_uuid(root_volume_uuid) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in backup_storage_list: bs_uuid_list.append(bs.uuid) image_option.set_backup_storage_uuid_list(bs_uuid_list) test_util.test_dsc('create image template from root volume') image2 = zstack_img_header.ZstackTestImage() image2.set_creation_option(image_option) image2.create() test_obj_dict.add_image(image2) image2.check() image2_uuid = image2.get_image().uuid test_util.test_dsc('create vm2 with new created template and check') vm_creation_option = vm.get_creation_option() vm_creation_option.set_image_uuid(image2_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm2.destroy() test_obj_dict.rm_vm(vm2) test_util.test_dsc('create snapshot4 and finally delete all snapshots') snapshots.create_snapshot('create_snapshot4') snapshot4 = snapshots.get_current_snapshot() snapshot4.backup() snapshots.check() snapshots.delete() test_obj_dict.rm_volume_snapshot(snapshots) test_util.test_dsc('create image template2 from root volume') image3 = zstack_img_header.ZstackTestImage() image3.set_creation_option(image_option) image3.create() test_obj_dict.add_image(image3) image3.check() image3_uuid = image3.get_image().uuid test_util.test_dsc('create vm3 with new created template and check') vm_creation_option.set_image_uuid(image3_uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() vm3.destroy() test_obj_dict.rm_vm(vm3) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create image from root volume with creating/destroying Snapshot 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 cluster_uuid global l2_uuid 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 l3 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name1)[0] l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0] l2_2 = res_ops.get_resource(res_ops.L2_NETWORK, \ uuid = l3_2.l2NetworkUuid)[0] l2_uuid = l2_2.uuid all_attached_clusters = l2_2.attachedClusterUuids l2_name2 = l2_2.name 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_l3_uuids([l3_1.uuid, l3_2.uuid]) cluster1_name = os.environ.get('clusterName2') cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0] cluster_uuid = cluster1.uuid vm_creation_option.set_cluster_uuid(cluster_uuid) vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) net_ops.detach_l2(l2_uuid, cluster_uuid) test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) vm1.update() vm1.set_state(vm_header.STOPPED) check_detach_l2(cluster_uuid, l2_uuid, vm1, True) #for num in range(len(all_attached_clusters)): # curr_cluster_uuid = vm1.get_vm().clusterUuid # # test_util.test_dsc('Detach l2_2') # net_ops.detach_l2(l2_uuid, curr_cluster_uuid) # # test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) # vm1.update() # vm1.set_state(vm_header.STOPPED) # # vm1.check() # # if num != len(all_attached_clusters) - 1: # check_detach_l2(curr_cluster_uuid, l2_uuid, vm1, True) # else: # check_detach_l2(curr_cluster_uuid, l2_uuid, vm1, False) #for cluster in all_attached_clusters: # net_ops.attach_l2(l2_uuid, cluster) net_ops.attach_l2(l2_uuid, cluster_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) #check vm1 vm2 status. vm2.check() vm1.destroy() vm2.destroy() test_util.test_pass('Detach L2 Test Success')
def test(): global ps_inv global ps_uuid global cluster_uuid 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 #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] ps_uuid = ps_inv.uuid 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_ps_ops') tag = tag_ops.create_system_tag('InstanceOfferingVO', \ instance_offering_uuid, \ 'primaryStorage::allocator::uuid::%s' % ps_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) cluster_uuid = vm1.get_vm().clusterUuid test_util.test_dsc("Detach Primary Storage") ps_ops.detach_primary_storage(ps_uuid, cluster_uuid) test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) vm1.update() vm1.set_state(vm_header.STOPPED) vm1.check() vm1.start() vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) test_util.test_dsc("Delete Primary Storage") 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.set_state(vm_header.DESTROYED) vm1.check() test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED) vm2.set_state(vm_header.DESTROYED) vm2.check() try: vm3 = test_lib.lib_create_vm(vm_creation_option) except: test_util.test_logger( 'Catch expected vm creation exception, since primary storage has been deleted. ' ) else: test_util.test_fail( 'Fail: Primary Storage has been deleted. But vm is still created with it.' ) test_stub.recover_ps(ps_inv) test_util.test_dsc("Attach Primary Storage") test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test primary storage operations Success')
def test(): global curr_deploy_conf global l3_2 l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0] 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 l3 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_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_basic_vm') vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.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) test_util.test_dsc('Delete l3_2') net_ops.delete_l3(l3_2.uuid) #Since 0.8, delete L3 won't delete VM. It will just detach L3 nic. #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) vm1.check() vm2.check() #test_util.test_dsc('start vm again. vm should remove the deleted l3') #vm1.start() #vm2.start() net_ops.add_l3_resource(curr_deploy_conf, l3_name = l3_2.name) #update l3_2, since it is readded. l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0] vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid]) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) #check vm1 vm2 status. vm1.check() vm2.check() if not len(vm1.get_vm().vmNics) == 1: test_util.test_fail('vm1 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) if not len(vm2.get_vm().vmNics) == 1: test_util.test_fail('vm2 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) #check vm3 status vm3.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L3 Test Success')
def test(): global ir_option vm_creation_option = test_util.VmOption() l3_name = os.environ.get('l3VlanNetworkNameMultiRange') l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0] vm_creation_option.set_l3_uuids([l3.uuid]) image_name = os.environ.get('imageName_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid 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_delete_ip_range') ir1 = res_ops.get_resource(res_ops.IP_RANGE, name = ir1_name)[0] ir_option.set_name(ir1_name) ir_option.set_description(ir1.description) ir_option.set_netmask(ir1.netmask) ir_option.set_gateway(ir1.gateway) ir_option.set_l3_uuid(ir1.l3NetworkUuid) ir_option.set_startIp(ir1.startIp) ir_option.set_endIp(ir1.endIp) ir_start_ip = ip_header.IpAddress(ir1.startIp) ir_end_ip = ip_header.IpAddress(ir1.endIp) #test_util.test_dsc('create vms') #vm1 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm1) #vm1_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm1_ip) #vm2 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm2) #vm2_ip = ip_header.IpAddress(vm2.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm2_ip) #vm3 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm3) #vm3_ip = ip_header.IpAddress(vm3.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm3_ip) #vm4 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm4) #vm4_ip = ip_header.IpAddress(vm4.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm4_ip) test_util.test_dsc('create vm and make sure vm ip range is in ir1.') ip_range_flag = False try_times = 0 while not ip_range_flag and try_times < 10: vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) vm1_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) test_util.test_logger('ip address: %s' % vm1_ip) if vm1_ip <= ir_end_ip and vm1_ip >= ir_start_ip: ip_range_flag = True break vm1.destroy() test_obj_dict.rm_vm(vm1) try_times += 1 if not ip_range_flag: test_util.test_fail('Can not deply IP address on [l3:] %s in [IP Range:] %s for %s times VMs creation. It might means the VM IP address allocation method has bug.' % (l3.uuid, ir1.uuid, try_times)) test_util.test_dsc('delete ip range') net_ops.delete_ip_range(ir1.uuid) #vm1_flag = False #vm2_flag = False #if vm1_ip <= ir_end_ip and vm1_ip >= ir_start_ip: # test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) # vm1.set_state(vm_header.STOPPED) # vm1.update() # vm1_flag = True #vm1.check() test_util.test_dsc('start vm with other ip range.') vm1.start() vm1_new_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) if vm1_ip == vm1_new_ip: test_util.test_fail('VM still get origianl [IP:] %s , after delete the IP Range.' % vm1_ip) if vm1_new_ip <= ir_end_ip and vm1_new_ip >= ir_start_ip: test_util.test_fail('VM still get unexpected [IP:] %s , after delete the IP Range: [%s] ~ [%s].' % (vm1_ip, ir_start_ip, ir_end_ip)) #The new start vm's IP address need to refresh (restart network srevice) vm1.check() net_ops.add_ip_range(ir_option) vm1.destroy() test_util.test_pass('Delete IP Range 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_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid #pick up host1 host1_name = os.environ.get('hostName') host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0] host3_name = os.environ.get('hostName3') host3 = res_ops.get_resource(res_ops.HOST, name=host3_name)[0] cond = res_ops.gen_query_conditions('clusterUuid', '=', host1.clusterUuid) cluster_hosts = res_ops.query_resource(res_ops.HOST, cond) if not len(cluster_hosts) > 1: test_util.test_skip( 'Skip test, since [cluster:] %s did not include more than 1 host' % host1.clusterUuid) for host in cluster_hosts: if host.uuid != host1.uuid: host2 = host 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) 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) vr_vm_inv = test_lib.lib_find_vr_by_vm(vm1.get_vm())[0] vr_host_uuid = vr_vm_inv.hostUuid #migrate vr to host3. if vr_host_uuid != host3.uuid: vm_ops.migrate_vm(vr_vm_inv.uuid, host3.uuid) host_config.set_cluster_uuid(host3.clusterUuid) host_config.set_username(os.environ.get('hostUsername')) host_config.set_password(os.environ.get('hostPassword')) host_config.set_name(host3_name) host_config.set_management_ip(host3.managementIp) target_host_uuid = host3.uuid test_util.test_dsc( "Delete VR VM's host. VR should be migrated to Cluster1") host_ops.delete_host(target_host_uuid) vm1.check() #using the same L3 to create VM2 to check if VR is working well. vm_creation_option.set_host_uuid(None) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() host_ops.add_kvm_host(host_config) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test VR migration when deleting Host is Success')
def test(): global ps_inv global ps_uuid global cluster_uuid 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 #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] ps_uuid = ps_inv.uuid 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_ps_ops') tag = tag_ops.create_system_tag('InstanceOfferingVO', \ instance_offering_uuid, \ 'primaryStorage::allocator::uuid::%s' % ps_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) cluster_uuid = vm1.get_vm().clusterUuid test_util.test_dsc("Detach Primary Storage") ps_ops.detach_primary_storage(ps_uuid, cluster_uuid) test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) vm1.update() vm1.set_state(vm_header.STOPPED) vm1.check() vm1.start() vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) test_util.test_dsc("Delete Primary Storage") 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.set_state(vm_header.DESTROYED) vm1.check() test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED) vm2.set_state(vm_header.DESTROYED) vm2.check() try: vm3 = test_lib.lib_create_vm(vm_creation_option) except: test_util.test_logger('Catch expected vm creation exception, since primary storage has been deleted. ') else: test_util.test_fail('Fail: Primary Storage has been deleted. But vm is still created with it.') test_stub.recover_ps(ps_inv) test_util.test_dsc("Attach Primary Storage") test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test primary storage operations Success')
def test(): global ps_uuid global cluster_uuid 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_s') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid cluster1_name = os.environ.get('clusterName1') cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0] #pick up primary storage 1 and set system tag for instance offering. ps_name1 = os.environ.get('nfsPrimaryStorageName1') ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0] ps_uuid = ps_inv.uuid cluster_uuid = cluster1.uuid 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_cluster_uuid(cluster_uuid) tag = tag_ops.create_system_tag('InstanceOfferingVO', \ instance_offering_uuid, \ 'primaryStorage::allocator::uuid::%s' % ps_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) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) volume1 = test_stub.create_volume() test_obj_dict.add_volume(volume1) volume1.attach(vm1) test_util.test_dsc("Detach Primary Storage") ps_ops.detach_primary_storage(ps_uuid, cluster_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) vm1.check() vm2.check() test_util.test_dsc("Attach Primary Storage") ps_ops.attach_primary_storage(ps_uuid, cluster_uuid) vm1.start() vm2.start() vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm1.check() volume1.check() vm2.check() vm3.check() test_util.test_dsc("Delete new added tag") tag_ops.delete_tag(tag.uuid) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test detaching 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) 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('Create original vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Create Data Volume obj.') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name( 'volume for create both root and data volume snapshot') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) test_util.test_dsc('Construct root volume obj.') vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) #root_volume = zstack_vol_header.ZstackTestVolume() #root_volume.set_volume(vm_root_volume_inv) #root_volume.set_target_vm(vm) #root_volume.set_state(vol_header.ATTACHED) root_volume_uuid = vm_root_volume_inv.uuid root_image_uuid = vm_root_volume_inv.rootImageUuid vm_img_inv = test_lib.lib_get_image_by_uuid(root_image_uuid) test_util.test_dsc('Stop vm before create snapshot.') vm.stop() test_util.test_dsc('create snapshot') snapshots_data = test_obj_dict.get_volume_snapshot( volume.get_volume().uuid) snapshots_data.set_utility_vm(vm1) snapshots_data.create_snapshot('create_data_snapshot1') snapshot1 = snapshots_data.get_current_snapshot() snapshots_data.create_snapshot('create_data_snapshot2') snapshots_data.create_snapshot('create_data_snapshot3') #snapshots_root = zstack_sp_header.ZstackVolumeSnapshot() #snapshots_root.set_target_volume(root_volume) #test_obj_dict.add_volume_snapshot(snapshots_root) snapshots_root = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots_root.set_utility_vm(vm1) snapshots_root.create_snapshot('create_root_snapshot1') snapshots_root.create_snapshot('create_root_snapshot2') snapshot2 = snapshots_root.get_current_snapshot() snapshots_root.create_snapshot('create_root_snapshot3') snapshot3 = snapshots_root.get_current_snapshot() test_util.test_dsc('delete snapshot3 and create image tempalte from root') snapshots_root.delete_snapshot(snapshot3) image_option = test_util.ImageOption() image_option.set_name('creating_image_from_root_volume_after_creating_sp') image_option.set_guest_os_type(vm_img_inv.guestOsType) image_option.set_bits(vm_img_inv.bits) image_option.set_root_volume_uuid(root_volume_uuid) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm( vm.get_vm()) bs_uuid_list = [] for bs in backup_storage_list: bs_uuid_list.append(bs.uuid) image_option.set_backup_storage_uuid_list(bs_uuid_list) test_util.test_dsc('create image template from root volume') image2 = zstack_img_header.ZstackTestImage() image2.set_creation_option(image_option) image2.create() test_obj_dict.add_image(image2) image2.check() image2_uuid = image2.get_image().uuid test_util.test_dsc('create vm2 with new created template and check') vm_creation_option = vm.get_creation_option() vm_creation_option.set_image_uuid(image2_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm2.destroy() test_obj_dict.rm_vm(vm2) #check data snapshots snapshots_data.use_snapshot(snapshot1) snapshots_data.create_snapshot('create_snapshot1.1.1') snapshots_data.create_snapshot('create_snapshot1.1.2') test_util.test_dsc( 'create snapshot4 and finally delete all snapshots_root') snapshots_root.create_snapshot('create_snapshot4') snapshot4 = snapshots_root.get_current_snapshot() snapshots_root.backup_snapshot(snapshot4) snapshots_root.check() vm.destroy() test_obj_dict.rm_vm(vm) test_util.test_dsc('create image template2 from root snapshot') image_option.set_root_volume_uuid(snapshot4.get_snapshot().uuid) snapshot4.set_image_creation_option(image_option) image3 = snapshot4.create_image_template() test_obj_dict.add_image(image3) image3.check() image3_uuid = image3.get_image().uuid test_util.test_dsc('create vm3 with new created template and check') vm_creation_option.set_image_uuid(image3_uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() vm3.destroy() test_obj_dict.rm_vm(vm3) #check data snapshots snapshots_data.use_snapshot(snapshot1) snapshots_data.create_snapshot('create_snapshot1.2.1') snapshots_data.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass( 'Create image from root volume with creating/destroying Snapshot 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 ir_option vm_creation_option = test_util.VmOption() l3_name = os.environ.get('l3VlanNetworkNameMultiRange') l3 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name)[0] vm_creation_option.set_l3_uuids([l3.uuid]) image_name = os.environ.get('imageName_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid 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_delete_ip_range') ir1 = res_ops.get_resource(res_ops.IP_RANGE, name=ir1_name)[0] ir_option.set_name(ir1_name) ir_option.set_description(ir1.description) ir_option.set_netmask(ir1.netmask) ir_option.set_gateway(ir1.gateway) ir_option.set_l3_uuid(ir1.l3NetworkUuid) ir_option.set_startIp(ir1.startIp) ir_option.set_endIp(ir1.endIp) ir_start_ip = ip_header.IpAddress(ir1.startIp) ir_end_ip = ip_header.IpAddress(ir1.endIp) #test_util.test_dsc('create vms') #vm1 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm1) #vm1_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm1_ip) #vm2 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm2) #vm2_ip = ip_header.IpAddress(vm2.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm2_ip) #vm3 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm3) #vm3_ip = ip_header.IpAddress(vm3.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm3_ip) #vm4 = test_lib.lib_create_vm(vm_creation_option) #test_obj_dict.add_vm(vm4) #vm4_ip = ip_header.IpAddress(vm4.get_vm().vmNics[0].ip) #test_util.test_logger('ip address: %s' % vm4_ip) test_util.test_dsc('create vm and make sure vm ip range is in ir1.') ip_range_flag = False try_times = 0 while not ip_range_flag and try_times < 10: vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) vm1_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) test_util.test_logger('ip address: %s' % vm1_ip) if vm1_ip <= ir_end_ip and vm1_ip >= ir_start_ip: ip_range_flag = True break vm1.destroy() test_obj_dict.rm_vm(vm1) try_times += 1 if not ip_range_flag: test_util.test_fail( 'Can not deply IP address on [l3:] %s in [IP Range:] %s for %s times VMs creation. It might means the VM IP address allocation method has bug.' % (l3.uuid, ir1.uuid, try_times)) test_util.test_dsc('delete ip range') net_ops.delete_ip_range(ir1.uuid) #vm1_flag = False #vm2_flag = False #if vm1_ip <= ir_end_ip and vm1_ip >= ir_start_ip: # test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) # vm1.set_state(vm_header.STOPPED) # vm1.update() # vm1_flag = True #vm1.check() test_util.test_dsc('start vm with other ip range.') vm1.start() vm1_new_ip = ip_header.IpAddress(vm1.get_vm().vmNics[0].ip) if vm1_ip == vm1_new_ip: test_util.test_fail( 'VM still get origianl [IP:] %s , after delete the IP Range.' % vm1_ip) if vm1_new_ip <= ir_end_ip and vm1_new_ip >= ir_start_ip: test_util.test_fail( 'VM still get unexpected [IP:] %s , after delete the IP Range: [%s] ~ [%s].' % (vm1_ip, ir_start_ip, ir_end_ip)) #The new start vm's IP address need to refresh (restart network srevice) vm1.check() net_ops.add_ip_range(ir_option) vm1.destroy() test_util.test_pass('Delete IP Range Test Success')
def test(): primary_storage_list = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for ps in primary_storage_list: if ps.type == "AliyunNAS": test_util.test_skip('The test is not supported by AliyunNAS primary storage.') test_util.test_dsc('Create original vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Construct volume obj.') vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) #root_volume = zstack_vol_header.ZstackTestVolume() #root_volume.set_volume(vm_root_volume_inv) #root_volume.set_state(vol_header.ATTACHED) root_image_uuid = vm_root_volume_inv.rootImageUuid vm_img_inv = test_lib.lib_get_image_by_uuid(root_image_uuid) test_util.test_dsc('Stop vm before create snapshot.') vm.stop() test_util.test_dsc('create snapshot and check') #snapshots = zstack_sp_header.ZstackVolumeSnapshot() #snapshots.set_target_volume(root_volume) #test_obj_dict.add_volume_snapshot(snapshots) snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm1) snapshots.create_snapshot('create_root_snapshot1') snapshots.check() snapshot1 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot2') snapshots.create_snapshot('create_snapshot3') snapshots.check() snapshot3 = snapshots.get_current_snapshot() test_util.test_dsc('create image template from sp3 and check') image_option = test_util.ImageOption() image_option.set_name('test_snapshot_creating_image') image_option.set_guest_os_type(vm_img_inv.guestOsType) image_option.set_bits(vm_img_inv.bits) image_option.set_root_volume_uuid(snapshot3.get_snapshot().uuid) snapshot3.set_image_creation_option(image_option) image3 = snapshot3.create_image_template() test_obj_dict.add_image(image3) image3_uuid = image3.get_image().uuid image3.check() vm_creation_option = vm.get_creation_option() vm_creation_option.set_image_uuid(image3_uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() test_util.test_dsc('create image template from sp1 and check') snapshot1.set_image_creation_option(image_option) image1 = snapshot3.create_image_template() test_obj_dict.add_image(image1) image1_uuid = image1.get_image().uuid image1.check() vm_creation_option.set_image_uuid(image1_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() snapshots.delete() test_obj_dict.rm_volume_snapshot(snapshots) vm2.check() vm3.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create image from Snapshot 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(): 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 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_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid #pick up host1 host1_name = os.environ.get('hostName') host1 = res_ops.get_resource(res_ops.HOST, name = host1_name)[0] cond = res_ops.gen_query_conditions('clusterUuid', '=', host1.clusterUuid) cluster_hosts = res_ops.query_resource(res_ops.HOST, cond) if not len(cluster_hosts) > 1: test_util.test_skip('Skip test, since [cluster:] %s did not include more than 1 host' % host1.clusterUuid) for host in cluster_hosts: if host.uuid != host1.uuid: host2 = host 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) 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) vr_vm_inv = test_lib.lib_find_vr_by_vm(vm1.get_vm())[0] vr_host_uuid = vr_vm_inv.hostUuid host_config.set_cluster_uuid(host1.clusterUuid) host_config.set_username(os.environ.get('hostUsername')) host_config.set_password(os.environ.get('hostPassword')) if vr_host_uuid != host1.uuid: vr_host_inv = res_ops.get_resource(res_ops.HOST, uuid = vr_host_uuid)[0] host_config.set_name(vr_host_inv.name) host_config.set_management_ip(vr_host_inv.managementIp) target_host_uuid = vr_host_inv.uuid else: host_config.set_name(host1_name) host_config.set_management_ip(host1.managementIp) target_host_uuid = host1.uuid test_util.test_dsc("Delete VR VM's host") host_ops.delete_host(target_host_uuid) if vr_host_uuid == host1.uuid: #if the deleted Host is VM1's host, need to restart VM1. test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) test_util.test_dsc('start vm on other host') vm1.start() vm1.check() #using the same L3 to create VM2 to check if VR is working well. vm_creation_option.set_host_uuid(None) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm1.reboot() vm1.check() host_ops.add_kvm_host(host_config) #update host1, since it is re-added again. host1 = res_ops.get_resource(res_ops.HOST, name = host1_name)[0] test_util.test_dsc('Create new VM on new added Host') vm_creation_option.set_host_uuid(host1.uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() #test_util.test_dsc('Delete VR Host again') #vr_new_inv = res_ops.get_resource(res_ops.VM_INSTANCE, \ # uuid = vr_vm_inv.uuid)[0] #vr_new_host_uuid = vr_new_inv.hostUuid #vr_new_host = res_ops.get_resource(res_ops.HOST, uuid = vr_new_host_uuid)[0] #host_config.set_name(vr_new_host.name) #host_config.set_management_ip(vr_new_host.managementIp) #host_ops.delete_host(target_host_uuid) #if vm1.get_vm().hostUuid == vr_new_host_uuid: # test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) # test_util.test_dsc('start vm on another host') # vm1.start() #vm1.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test VR migration when deleting Host is Success')
def test(): global curr_deploy_conf global l2_name2 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 l3 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name1)[0] l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name2)[0] l2_2 = res_ops.get_resource(res_ops.L2_NETWORK, \ uuid = l3_2.l2NetworkUuid)[0] l2_name2 = l2_2.name 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_l3_uuids([l3_1.uuid, l3_2.uuid]) cluster1_name = os.environ.get('clusterName2') cluster1 = res_ops.get_resource(res_ops.CLUSTER, name=cluster1_name)[0] vm_creation_option.set_cluster_uuid(cluster1.uuid) vm1 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm1) test_util.test_dsc('Delete l2_2') net_ops.delete_l2(l2_2.uuid) test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) vm1.update() vm1.set_state(vm_header.STOPPED) vm1.check() test_util.test_dsc('start vm again. vm should remove the deleted l2') vm1.start() net_ops.add_l2_resource(curr_deploy_conf, l2_name=l2_name2) #update l3_2, since it is readded. l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name2)[0] vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid]) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) #check vm1 vm2 status. vm1.check() if not len(vm1.get_vm().vmNics) == 1: test_util.test_fail( 'vm1 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) vm2.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L2 Test Success')
def test(): global ps_uuid global cluster_uuid 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_s') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid cluster1_name = os.environ.get('clusterName1') cluster1 = res_ops.get_resource(res_ops.CLUSTER, name=cluster1_name)[0] #pick up primary storage 1 and set system tag for instance offering. ps_name1 = os.environ.get('nfsPrimaryStorageName1') ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name=ps_name1)[0] ps_uuid = ps_inv.uuid cluster_uuid = cluster1.uuid 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_cluster_uuid(cluster_uuid) tag = tag_ops.create_system_tag('InstanceOfferingVO', \ instance_offering_uuid, \ 'primaryStorage::allocator::uuid::%s' % ps_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) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) volume1 = test_stub.create_volume() test_obj_dict.add_volume(volume1) volume1.attach(vm1) test_util.test_dsc("Detach Primary Storage") ps_ops.detach_primary_storage(ps_uuid, cluster_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) vm1.check() vm2.check() test_util.test_dsc("Attach Primary Storage") ps_ops.attach_primary_storage(ps_uuid, cluster_uuid) vm1.start() vm2.start() vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm1.check() volume1.check() vm2.check() vm3.check() test_util.test_dsc("Delete new added tag") tag_ops.delete_tag(tag.uuid) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test detaching primary storage 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(): primary_storage_list = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for ps in primary_storage_list: if ps.type == "AliyunNAS": test_util.test_skip('The test is not supported by AliyunNAS primary storage.') test_util.test_dsc('Create original vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Create Data Volume obj.') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for create both root and data volume snapshot') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) test_util.test_dsc('Construct root volume obj.') vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) #root_volume = zstack_vol_header.ZstackTestVolume() #root_volume.set_volume(vm_root_volume_inv) #root_volume.set_target_vm(vm) #root_volume.set_state(vol_header.ATTACHED) root_volume_uuid = vm_root_volume_inv.uuid root_image_uuid = vm_root_volume_inv.rootImageUuid vm_img_inv = test_lib.lib_get_image_by_uuid(root_image_uuid) test_util.test_dsc('Stop vm before create snapshot.') vm.stop() test_util.test_dsc('create snapshot') snapshots_data = test_obj_dict.get_volume_snapshot(volume.get_volume().uuid) snapshots_data.set_utility_vm(vm1) snapshots_data.create_snapshot('create_data_snapshot1') snapshot1 = snapshots_data.get_current_snapshot() snapshots_data.create_snapshot('create_data_snapshot2') snapshots_data.create_snapshot('create_data_snapshot3') #snapshots_root = zstack_sp_header.ZstackVolumeSnapshot() #snapshots_root.set_target_volume(root_volume) #test_obj_dict.add_volume_snapshot(snapshots_root) snapshots_root = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots_root.set_utility_vm(vm1) snapshots_root.create_snapshot('create_root_snapshot1') snapshots_root.create_snapshot('create_root_snapshot2') snapshot2 = snapshots_root.get_current_snapshot() snapshots_root.create_snapshot('create_root_snapshot3') snapshot3 = snapshots_root.get_current_snapshot() test_util.test_dsc('delete snapshot3 and create image tempalte from root') snapshots_root.delete_snapshot(snapshot3) image_option = test_util.ImageOption() image_option.set_name('creating_image_from_root_volume_after_creating_sp') image_option.set_guest_os_type(vm_img_inv.guestOsType) image_option.set_bits(vm_img_inv.bits) image_option.set_root_volume_uuid(root_volume_uuid) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in backup_storage_list: bs_uuid_list.append(bs.uuid) image_option.set_backup_storage_uuid_list(bs_uuid_list) test_util.test_dsc('create image template from root volume') image2 = zstack_img_header.ZstackTestImage() image2.set_creation_option(image_option) image2.create() test_obj_dict.add_image(image2) image2.check() image2_uuid = image2.get_image().uuid test_util.test_dsc('create vm2 with new created template and check') vm_creation_option = vm.get_creation_option() vm_creation_option.set_image_uuid(image2_uuid) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm2.destroy() test_obj_dict.rm_vm(vm2) ps_uuid = vm_root_volume_inv.primaryStorageUuid ps = test_lib.lib_get_primary_storage_by_uuid(ps_uuid) if ps.type == inventory.LOCAL_STORAGE_TYPE: # LOCAL Storage do not support create volume and template from backuped snapshot test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create image from root volume with creating/destroying Snapshot Success') #check data snapshots snapshots_data.use_snapshot(snapshot1) snapshots_data.create_snapshot('create_snapshot1.1.1') snapshots_data.create_snapshot('create_snapshot1.1.2') test_util.test_dsc('create snapshot4 and finally delete all snapshots_root') snapshots_root.create_snapshot('create_snapshot4') snapshot4 = snapshots_root.get_current_snapshot() #snapshots_root.backup_snapshot(snapshot4) snapshots_root.check() #vm.destroy() #test_obj_dict.rm_vm(vm) test_util.test_dsc('create image template2 from root snapshot') image_option.set_root_volume_uuid(snapshot4.get_snapshot().uuid) snapshot4.set_image_creation_option(image_option) image3 = snapshot4.create_image_template() test_obj_dict.add_image(image3) image3.check() image3_uuid = image3.get_image().uuid test_util.test_dsc('create vm3 with new created template and check') vm_creation_option.set_image_uuid(image3_uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() vm3.destroy() test_obj_dict.rm_vm(vm3) #check data snapshots snapshots_data.use_snapshot(snapshot1) snapshots_data.create_snapshot('create_snapshot1.2.1') snapshots_data.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create image from root volume with creating/destroying Snapshot 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_net') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid #pick up host1 host1_name = os.environ.get('hostName') host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0] cond = res_ops.gen_query_conditions('clusterUuid', '=', host1.clusterUuid) cluster_hosts = res_ops.query_resource(res_ops.HOST, cond) if not len(cluster_hosts) > 1: test_util.test_skip( 'Skip test, since [cluster:] %s did not include more than 1 host' % host1.clusterUuid) for host in cluster_hosts: if host.uuid != host1.uuid: host2 = host 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) 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) vr_vm_inv = test_lib.lib_find_vr_by_vm(vm1.get_vm())[0] vr_host_uuid = vr_vm_inv.hostUuid host_config.set_cluster_uuid(host1.clusterUuid) host_config.set_username(os.environ.get('hostUsername')) host_config.set_password(os.environ.get('hostPassword')) if vr_host_uuid != host1.uuid: vr_host_inv = res_ops.get_resource(res_ops.HOST, uuid=vr_host_uuid)[0] host_config.set_name(vr_host_inv.name) host_config.set_management_ip(vr_host_inv.managementIp) target_host_uuid = vr_host_inv.uuid else: host_config.set_name(host1_name) host_config.set_management_ip(host1.managementIp) target_host_uuid = host1.uuid test_util.test_dsc("Delete VR VM's host") host_ops.delete_host(target_host_uuid) if vr_host_uuid == host1.uuid: #if the deleted Host is VM1's host, need to restart VM1. test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) test_util.test_dsc('start vm on other host') vm1.start() vm1.check() #using the same L3 to create VM2 to check if VR is working well. vm_creation_option.set_host_uuid(None) vm2 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm2) vm2.check() vm1.reboot() vm1.check() host_ops.add_kvm_host(host_config) #update host1, since it is re-added again. host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0] test_util.test_dsc('Create new VM on new added Host') vm_creation_option.set_host_uuid(host1.uuid) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) vm3.check() #test_util.test_dsc('Delete VR Host again') #vr_new_inv = res_ops.get_resource(res_ops.VM_INSTANCE, \ # uuid = vr_vm_inv.uuid)[0] #vr_new_host_uuid = vr_new_inv.hostUuid #vr_new_host = res_ops.get_resource(res_ops.HOST, uuid = vr_new_host_uuid)[0] #host_config.set_name(vr_new_host.name) #host_config.set_management_ip(vr_new_host.managementIp) #host_ops.delete_host(target_host_uuid) #if vm1.get_vm().hostUuid == vr_new_host_uuid: # test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED) # test_util.test_dsc('start vm on another host') # vm1.start() #vm1.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test VR migration when deleting Host is 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(): global curr_deploy_conf global l3_2 l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name2)[0] 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 l3 l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_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_basic_vm') vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.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) test_util.test_dsc('Delete l3_2') net_ops.delete_l3(l3_2.uuid) #Since 0.8, delete L3 won't delete VM. It will just detach L3 nic. #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) vm1.check() vm2.check() #test_util.test_dsc('start vm again. vm should remove the deleted l3') #vm1.start() #vm2.start() net_ops.add_l3_resource(curr_deploy_conf, l3_name=l3_2.name) #update l3_2, since it is readded. l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name2)[0] vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid]) vm3 = test_lib.lib_create_vm(vm_creation_option) test_obj_dict.add_vm(vm3) #check vm1 vm2 status. vm1.check() vm2.check() if not len(vm1.get_vm().vmNics) == 1: test_util.test_fail( 'vm1 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) if not len(vm2.get_vm().vmNics) == 1: test_util.test_fail( 'vm2 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid) #check vm3 status vm3.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete L3 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')