def test_create_resourcepool_template(uri, headers, init_name, resourcepool,
loading, password, username,
template_name, resourcepoolType):
images_Id = str(get_image_id(uri, headers, init_name))
resourcePoolId = get_resourcepoolid(uri, headers, resourcepool)
relavant_id = str(
get_template_id(uri, headers, resourcepoolType, resourcepool,
template_name))
relation_url = "/relations"
create_resourcepool_template_param = [{
"imageId": images_Id,
"loading": loading,
"extra": {
"password": password,
"username": username
},
"relavant": {},
"relavantId": relavant_id,
"relavantName": template_name,
"resourcepoolId": resourcePoolId,
"resourcepoolType": resourcepoolType
}]
create_resourcepool_template_response = requests.post(
url=uri + get_images_url + images_Id + relation_url,
json=create_resourcepool_template_param,
headers=headers).json()
allure.attach("请求响应code",
str(create_resourcepool_template_response['status']))
allure.attach("请求响应结果", str(create_resourcepool_template_response))
my_log().info(create_resourcepool_template_response)
assert create_resourcepool_template_response["status"] == 200
# 断言创建的模板关联能在查询到的响应结果中存在
assert template_name in get_template_name_list(uri, headers, init_name)
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 test_update_network_object(uri, headers, resourcepool, network_name,
objectName, updata_object_name,
resourcePoolType):
id = get_network_object_id(uri, headers, resourcepool, network_name,
objectName)
network_id = get_network_id(uri, headers, network_name)
object_id = get_network_dvportgroup_id(uri, headers, resourcePoolType,
resourcepool, updata_object_name)
resourcePoolId = get_resourcepoolid(uri, headers, resourcepool)
param = {
# 'id': id,
'networkId': network_id,
'objectId': object_id,
'objectName': updata_object_name,
# 'objectType': 'DistributePortGroup',
'resourcePoolId': resourcePoolId
# 'resourcePoolName': resourcepool,
# 'resourcePoolType': resourcePoolType
}
update_network_object_response = requests.put(
url=uri + update_network_object_url_path + str(id) + '?networkId=' +
str(network_id),
headers=headers,
json=param).json()
code = update_network_object_response['status']
allure.attach("请求响应code", str(update_network_object_response['status']))
allure.attach("请求响应结果", str(update_network_object_response))
my_log().info(update_network_object_response)
assert code == 200
def get_object_id(uri, headers, resourcepool, network_name):
networkId = get_network_id(uri, headers, network_name)
resourcepoolId = get_resourcepoolid(uri, headers, resourcepool)
data_url = {"networkdId": networkId, "resourcePoolId": resourcepoolId}
query_object = urllib.parse.urlencode(data_url)
get_object_response = requests.get(url=uri + network_object_url_path +
"?" + query_object,
headers=headers).json()
for object in get_object_response['data']:
return object['objectId']
def get_instance_vmName(uri, headers, instance_name, resourcepool):
resourcePoolId = get_resourcepoolid(uri, headers, resourcepool)
url_data = {
"resourcePoolId": resourcePoolId,
"start": 0,
"limit": 100
}
query_vms = urllib.parse.urlencode(url_data)
get_instance_response = requests.get(url=uri + create_instance_url + "?" + query_vms,
headers=headers).json()
for instance in get_instance_response["data"]["list"]:
if instance["name"] == instance_name:
return instance["vmName"]
def get_template_list(uri, headers, resourcepoolType, resourcepool):
template_list = []
resourcepool_id = get_resourcepoolid(uri, headers, resourcepool)
if resourcepoolType == "vmware":
get_vmware_template_response = requests.get(
url=uri + get_vmware_templates_url + str(resourcepool_id),
headers=headers).json()
template_list = get_vmware_template_response['data']
elif resourcepoolType == "openstack":
get_openstack_template_response = requests.get(
url=uri + get_openstack_templates_url + str(resourcepool_id),
headers=headers).json()
template_list = get_openstack_template_response['data']
# print(template_list)
return template_list
def test_update_vlanpool(uri,headers,vlanpool_name,update_vlanpool_name,ResourcePool,vlanTagStart,vlanTagEnd):
vlanpoolId=get_vlanpool_id(uri,headers,vlanpool_name)
resourcepoolid = get_resourcepoolid(uri, headers, ResourcePool)
update_vlanpool_param={
'name':update_vlanpool_name,
'vlanTagStart':vlanTagStart,
'vlanTagEnd':vlanTagEnd,
'vlanPoolResourcePoolList': [{'resourcePoolId': resourcepoolid,'vlanPoolId':vlanpoolId}]
}
update_vlanpool_response=requests.put(url=uri+update_vlanpool_url_path+str(vlanpoolId),
headers=headers,json=update_vlanpool_param).json()
allure.attach("请求响应code", str(update_vlanpool_response['status']))
allure.attach("请求响应结果", str(update_vlanpool_response))
my_log().info(update_vlanpool_response)
assert update_vlanpool_response['status'] == 200
def get_network_dvportgroup_list(uri, headers, resourcePoolType,
network_resourcepool_name):
network_resourcepool_id = get_resourcepoolid(uri, headers,
network_resourcepool_name)
network_dvportgroup_list = []
if resourcePoolType == "vmware":
network_dvportgroup_response = requests.get(
url=uri + get_network_dvportgroup_url_path +
str(network_resourcepool_id),
headers=headers).json()
network_dvportgroup_list = network_dvportgroup_response['data']
elif resourcePoolType == "openstack":
network_dvportgroup_response = requests.get(
url=uri + get_network_openstack_url_path +
str(network_resourcepool_id),
headers=headers).json()
network_dvportgroup_list = network_dvportgroup_response['data']
return network_dvportgroup_list
def test_create_vlanpool(uri, headers, name, tag, ResourcePoolName, vlanTagStart, vlanTagEnd):
resourcepoolid = get_resourcepoolid(uri, headers, ResourcePoolName)
param = {
'name': name, # VLAN池名称
'tag': tag,
'vlanPoolResourcePoolList': [{'resourcePoolId': resourcepoolid}], #作用域调用资源池ID
'vlanTagEnd': vlanTagStart, # 结束VLAN ID
'vlanTagStart': vlanTagEnd # 起始VLAN ID
}
create_vlanpool_response = requests.post(
url=uri + create_vlanpool_url_path,
headers=headers,
json=param
).json()
print(create_vlanpool_response)
code = create_vlanpool_response['status']
allure.attach("请求响应code", str(create_vlanpool_response['status']))
allure.attach("请求响应结果", str(create_vlanpool_response))
my_log().info(create_vlanpool_response)
assert code == 200
def test_create_network_object(uri, headers, network_name, resourcePoolType,
network_resourcepool_name, object_name,
dvsName):
network_id = get_network_id(uri, headers, network_name)
network_resourcepool_id = get_resourcepoolid(uri, headers,
network_resourcepool_name)
param = [{
'name': object_name,
'dvsName': dvsName,
'resourcePoolId': network_resourcepool_id,
# 'resourcePoolType': resourcePoolType
}]
create_network_object_response = requests.post(
url=uri + create_network_object_url_path + str(network_id),
headers=headers,
json=param[0]).json()
code = create_network_object_response['status']
allure.attach("请求响应code", str(create_network_object_response['status']))
allure.attach("请求响应结果", str(create_network_object_response))
my_log().info(create_network_object_response)
assert code == 200
def test_add_network_object(uri, headers, network_name, resourcePoolType,
network_resourcepool_name, objectname):
network_id = get_network_id(uri, headers, network_name)
network_resourcepool_id = get_resourcepoolid(uri, headers,
network_resourcepool_name)
objectId = get_network_dvportgroup_id(uri, headers, resourcePoolType,
network_resourcepool_name,
objectname)
param = [{
'objectId': objectId,
'objectName': objectname,
'resourcePoolId': network_resourcepool_id,
'resourcePoolType': resourcePoolType,
'vlanPoolResourcePoolId': network_resourcepool_id
}]
add_network_object_response = requests.post(
url=uri + add_network_object_url_path + str(network_id),
headers=headers,
json=param).json()
allure.attach("请求响应code", str(add_network_object_response['status']))
allure.attach("请求响应结果", str(add_network_object_response))
my_log().info(add_network_object_response)
assert add_network_object_response['status'] == 200
def test_create_images(uri, headers, name, description, os, osType, password,
username, loading, resourcepool, resourcepoolType,
template_name):
templateId = get_template_id(uri, headers, resourcepoolType, resourcepool,
template_name)
resourcepoolid = get_resourcepoolid(uri, headers, resourcepool)
create_images_param = {
"description":
description,
"name":
name,
"os":
os,
"osType":
osType,
"relations": [{
"extra": {
"password": password,
"username": username
},
"loading": loading,
"relavant": {},
"relavantId": templateId,
"relavantName": template_name,
"resourcepoolId": resourcepoolid,
"resourcepoolType": resourcepoolType
}]
}
create_images_response = requests.post(url=uri + create_images_url,
json=create_images_param,
headers=headers).json()
allure.attach("请求响应code", str(create_images_response['status']))
allure.attach("请求响应结果", str(create_images_response))
my_log().info(create_images_response)
assert create_images_response['status'] == 200
# 断言创建的镜像名称能在查询到的响应结果中存在
assert name in get_images_name_list(uri, headers)
def test_create_vm(uri, headers, resourcepooltype,region,resourcepool, tenant, project, vmname,
account,image, ostype,cluster,host,cpu,memory,osdisk,disktype,net,subnet,nettype,ipaddress,status_code,expected_result,expected_db):
resourcePoolId = get_resourcepoolid(uri, headers, resourcepool)
tenantId = get_tenant_id(uri, headers, tenant)
projectId = get_project_id(uri, headers, project)
netId = get_network_id(uri, headers, net)
subnetId = get_subnet_id(uri, headers, net, subnet)
imageId = get_image_id(uri, headers,image)
subnetipId = get_subnetip_id(uri, headers, net, subnet, ipaddress)
objectId = get_object_id(uri, headers, resourcepool, net)
global targetId
if resourcepooltype == "vmware":
targetId = objectId
elif resourcepooltype == "openstack":
targetId = netId
create_instance_data = [{
"count": account,
"regionId": get_datacenterid(uri, headers, region),
"resourcePoolId": resourcePoolId,
"vdcId": tenantId,
"projectId": projectId,
"hypervisorType": resourcepooltype,
"name": vmname,
"description": "",
"imageId": imageId,
"osType": ostype,
"cpu": cpu,
"memory": memory,
"osDatastore": "",
"disks": [{
"name": "系统盘",
"os": "true",
"size": osdisk,
"type": ostype,
"configs": {
"datastore": ""
}
}],
"nics": [{
"name": net,
"networkId": netId,
"subnetId": subnetId,
"ipId": subnetipId,
"ip": ipaddress,
"type": nettype,
"targetId": targetId,
"extra": {}
}],
"placement":{
"cluster": cluster,
"host": host
}
}]
create_vm_response = requests.post(url = uri + create_instance_url,
headers = headers,
data=json.dumps(create_instance_data)).json()
allure.attach("请求响应code", str(create_vm_response['status']))
allure.attach("请求响应结果", str(create_vm_response))
my_log().info(create_vm_response)
AssertUtil().assert_code(create_vm_response['status'], status_code)
time.sleep(120)
AssertUtil().assert_in_body(create_vm_response['data'], expected_result)
assert_mysqldb(get_instance_db(vmname), expected_db)
