def test_instance_clone(uri, headers, cloned_vmname, resourcepool, count, region, tenant, project, hypervisorType, name, ostype, cpu, memory, network, subnet, ipaddress):
instance_id = get_instance_id(uri, headers, cloned_vmname, resourcepool)
instance_clone_url = create_instance_url + "/" + str(instance_id) + "/clone"
region_id = get_datacenterid(uri, headers, region)
resourcepool_id = get_resourcepoolid(uri, headers, resourcepool)
tenant_id = get_tenant_id(uri, headers, tenant)
project_id = get_project_id(uri, headers, project)
disk = get_instance_disks(uri, headers, cloned_vmname, resourcepool)
nic = get_intance_nics(uri, headers, cloned_vmname, resourcepool)
network_id = get_network_id(uri, headers, network)
subnet_id = get_subnet_id(uri, headers, network, subnet)
ip_id = get_subnetip_id(uri, headers, network, subnet, ipaddress)
object_id = get_object_id(uri,headers, resourcepool,network)
instance_clone_param =[{
"count" : count,
"regionId" : region_id,
"resourcePoolId" : resourcepool_id,
"vdcId" : tenant_id,
"projectId" : project_id,
"hypervisorType" : hypervisorType,
"name" : name,
"description" : "",
"imageId" : "" ,
"osType" : ostype,
"cpu" : cpu,
"memory" : memory,
"osDatastore" : "",
"disks" : [{
"os" : disk["os"],
"size" : disk["size"],
"id" : None,
"name" : disk["name"],
"diskId" : None,
"diskName" : disk["diskName"],
"instanceId" : None,
"type" : disk["type"],
"configs" : {
"datastore" : ""
}
}],
"nics" : [{
"id" : "",
"instanceId" : "",
"networkId" : network_id,
"subnetId" : subnet_id,
"ipId" : ip_id,
"ip" : ipaddress,
"targetId": object_id,
"type" : nic["type"],
}]
}]
instance_clone_response = requests.post(url = uri + instance_clone_url,
headers = headers,
data = json.dumps(instance_clone_param)).json()
allure.attach("请求响应code", str(instance_clone_response['status']))
allure.attach("请求响应结果", str(instance_clone_response))
my_log().info(instance_clone_response)
assert instance_clone_response["status"] == 200
time.sleep(300)
def get_snapshot_id(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
get_snapshot_url = create_instance_url + "/" + str(instance_id) + "/snapshots"
get_snapshot_response = requests.get(url = uri + get_snapshot_url,
headers = headers).json()
# if get_snapshot_response["name"] == snapshotName:
return get_snapshot_response["data"][0]["id"]
def test_instance_migrate(uri, headers, vmname, resourcepool, hostname, storename):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_migrate_url = create_instance_url + "/" + str(instance_id) + "/migrate"
instance_migrateHost_data = {
"instanceId": instance_id,
"migrateType": "MigrateHost",
"hostName": hostname
}
instance_migrateStore_data = {
"instanceId": instance_id,
"migrateType": "MigrateStore",
"storeName": storename
}
instance_migrateHost_response = requests.put(url = uri + instance_migrate_url,
headers = headers,
data = json.dumps(instance_migrateHost_data)).json()
allure.attach("请求响应code", str(instance_migrateHost_response['status']))
allure.attach("请求响应结果", str(instance_migrateHost_response))
my_log().info(instance_migrateHost_response)
assert instance_migrateHost_response["status"] == 200
time.sleep(30)
instance_migrateStore_response = requests.put(url = uri + instance_migrate_url,
headers = headers,
data = json.dumps(instance_migrateStore_data)).json()
allure.attach("请求响应code", str(instance_migrateStore_response['status']))
allure.attach("请求响应结果", str(instance_migrateStore_response))
my_log().info(instance_migrateStore_response)
assert instance_migrateStore_response["status"] == 200
def get_instance_nicId(uri, headers, instance_name, resourcepool, ipaddress):
instance_id = get_instance_id(uri, headers, instance_name, resourcepool)
get_instance_nics_url = create_instance_url + "/" + str(instance_id) + "/nics"
get_instance_nics_response = requests.get(url=uri + get_instance_nics_url,
headers = headers).json()
for nic in get_instance_nics_response["data"]:
if nic["ip"] == ipaddress:
return nic["id"]
def test_instance_delete(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_delete_url = create_instance_url + "/" + str(instance_id)
instance_delete_response = requests.delete(url= uri + instance_delete_url,
headers = headers).json()
allure.attach("请求响应code", str(instance_delete_response['status']))
allure.attach("请求响应结果", str(instance_delete_response))
my_log().info(instance_delete_response)
assert instance_delete_response["status"] == 200
time.sleep(300)
def test_instance_delete_nic(uri, headers, vmname, resourcepool, ipaddress):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
nic_id = get_instance_nicId(uri, headers, vmname, resourcepool, ipaddress)
instance_deleteNic_url = create_instance_url + "/" + str(instance_id) + "/nics/" + str(nic_id)
instance_deleteNic_response = requests.delete(url=uri + instance_deleteNic_url,
headers = headers).json()
allure.attach("请求响应code", str(instance_deleteNic_response['status']))
allure.attach("请求响应结果", str(instance_deleteNic_response))
my_log().info(instance_deleteNic_response)
assert instance_deleteNic_response["status"] == 200
def test_instance_resetOs(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_resetOs_url = create_instance_url + "/" + str(instance_id) + "/resetOs"
instance_resetOs_response = requests.put(url = uri + instance_resetOs_url,
headers = headers).json()
allure.attach("请求响应code", str(instance_resetOs_response['status']))
allure.attach("请求响应结果", str(instance_resetOs_response))
my_log().info(instance_resetOs_response)
assert instance_resetOs_response["status"] == 200
#重置虚拟机后等待5min，需要等待虚拟机创建完成
time.sleep(300)
def test_instance_sync(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_sync_url = create_instance_url + "/sync"
instance_sync_data = [instance_id]
instance_sync_response = requests.post(url = uri + instance_sync_url,
headers = headers,
data = json.dumps(instance_sync_data)).json()
allure.attach("请求响应code", str(instance_sync_response['status']))
allure.attach("请求响应结果", str(instance_sync_response))
my_log().info(instance_sync_response)
assert instance_sync_response["status"] == 200
def test_instance_resume(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_resume_url = create_instance_url +"/" + str(instance_id) + "/resume"
instance_resume_response = requests.post(url = uri + instance_resume_url,
headers = headers).json()
allure.attach("请求响应code", str(instance_resume_response['status']))
allure.attach("请求响应结果", str(instance_resume_response))
my_log().info(instance_resume_response)
assert instance_resume_response["status"] == 200
#虚拟机恢复后等待15s
time.sleep(120)
def test_instance_deleteSnapshot(uri, headers):
vmname = instance_snapshot_data[0][0]
resourcepool = instance_snapshot_data[0][1]
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
snapshot_id = get_snapshot_id(uri, headers, vmname,resourcepool)
instance_deleteSnapshot_url = create_instance_url + "/" + str(instance_id) + "/snapshots/" + str(snapshot_id)
instance_deleteSnapshot_response = requests.delete(url = uri + instance_deleteSnapshot_url,
headers = headers).json()
allure.attach("请求响应code", str(instance_deleteSnapshot_response['status']))
allure.attach("请求响应结果", str(instance_deleteSnapshot_response))
my_log().info(instance_deleteSnapshot_response)
assert instance_deleteSnapshot_response["status"] == 200
def test_instance_shutdownOS(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_shutdownOS_url = create_instance_url +"/" + str(instance_id) + "/shutdownOS"
instance_shutdownOS_data = {
"instanceId": instance_id
}
instance_shutdownOS_response = requests.post(url = uri + instance_shutdownOS_url,
headers = headers,
data = json.dumps(instance_shutdownOS_data)).json()
allure.attach("请求响应code", str(instance_shutdownOS_response['status']))
allure.attach("请求响应结果", str(instance_shutdownOS_response))
my_log().info(instance_shutdownOS_response)
assert instance_shutdownOS_response["status"] == 200
#虚拟机软重启后等待120s
time.sleep(120)
def test_instance_configCpuAndMemory(uri, headers, cpu, memory, name, resourcepool):
instance_id = get_instance_id(uri, headers, name, resourcepool )
vmName = get_instance_vmName(uri, headers, name, resourcepool)
configCpuAndMemory_url = create_instance_url + "/" + str(instance_id) +"/configCpuAndMemory"
configCpuAndMemory_data = {
"cpu": cpu,
"memory": memory,
"vmName": vmName,
"name": name
}
configCpuAndMemory_response = requests.put(url= uri + configCpuAndMemory_url,
headers = headers,
data=json.dumps(configCpuAndMemory_data)).json()
allure.attach("请求响应code", str(configCpuAndMemory_response['status']))
allure.attach("请求响应结果", str(configCpuAndMemory_response))
my_log().info(configCpuAndMemory_response)
assert configCpuAndMemory_response["status"] == 200
def test_instance_powerOff(uri, headers, vmname, resourcepool):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_powerOff_url = create_instance_url + "/" + str(instance_id) + "/powerOff"
instance_powerOff_data = {
"instanceId": instance_id
}
instance_powerOff_response = requests.post(url=uri + instance_powerOff_url,
headers=headers,
data=json.dumps(instance_powerOff_data)).json()
allure.attach("请求响应code", str(instance_powerOff_response['status']))
allure.attach("请求响应结果", str(instance_powerOff_response))
my_log().info(instance_powerOff_response)
assert instance_powerOff_response["status"] == 200
# 虚拟机关机后等待60s再开机
time.sleep(60)
def test_instance_createSnapshot(uri, headers, vmname, resourcepool, name, desc, memory, quiesce):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_createSnapshot_url = create_instance_url + "/" + str(instance_id) + "/snapshots"
instance_createSnapshot_data = {
"instanceId": instance_id,
"name": name,
"desc": desc,
"memory": memory,
"quiesce": quiesce
}
instance_createSnapshot_response = requests.post(url = uri + instance_createSnapshot_url,
headers = headers,
data = json.dumps(instance_createSnapshot_data)).json()
allure.attach("请求响应code", str(instance_createSnapshot_response['status']))
allure.attach("请求响应结果", str(instance_createSnapshot_response))
my_log().info(instance_createSnapshot_response)
assert instance_createSnapshot_response["status"] == 200
#创建快照后等待2min
time.sleep(120)
def test_instance_disks(uri, headers, vmname, resourcepool, name, os, size, type, datastore):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
instance_disks_url = create_instance_url + "/" + str(instance_id) + "/disks"
instance_addDisk_data = {
"name": name,
"os": os,
"size": size,
"type": type,
"configs":{
"datastore": datastore
}
}
instance_addDisk_response = requests.post(url = uri + instance_disks_url,
headers = headers,
data = json.dumps(instance_addDisk_data)).json()
allure.attach("请求响应code", str(instance_addDisk_response['status']))
allure.attach("请求响应结果", str(instance_addDisk_response))
my_log().info(instance_addDisk_response)
assert instance_addDisk_response["status"] == 200
def test_instance_nic(uri, headers, vmname, resourcepool, resourcepoolType, network, subnet, ipaddress, type):
instance_id = get_instance_id(uri, headers, vmname, resourcepool)
networkId = get_network_id(uri, headers, network)
subnetId = get_subnet_id(uri, headers,network,subnet)
ipId = get_subnetip_id(uri, headers, network, subnet, ipaddress)
targetId = get_object_id(uri, headers, resourcepool, network)
instance_nic_url = create_instance_url + "/" + str(instance_id) + "/nics"
if resourcepoolType == "vmware":
instance_addNetwork_data = {
"networkId": networkId,
"subnetId": subnetId,
"ipId": ipId,
"ip": ipaddress,
"targetId": targetId,
"type": type
}
instance_addNetwork_response = requests.post(url = uri + instance_nic_url,
headers = headers,
data = json.dumps(instance_addNetwork_data)).json()
allure.attach("请求响应code", str(instance_addNetwork_response['status']))
allure.attach("请求响应结果", str(instance_addNetwork_response))
my_log().info(instance_addNetwork_response)
assert instance_addNetwork_response["status"] == 200
elif resourcepoolType == "openstack":
instance_addNetwork_data = {
"networkId": networkId,
"subnetId": subnetId,
"ipId": ipId,
"ip": ipaddress
}
instance_addNetwork_response = requests.post(url=uri + instance_nic_url,
headers=headers,
data=json.dumps(instance_addNetwork_data)).json()
allure.attach("请求响应code", str(instance_addNetwork_response['status']))
allure.attach("请求响应结果", str(instance_addNetwork_response))
my_log().info(instance_addNetwork_response)
assert instance_addNetwork_response["status"] == 200