def base_insert_user(self, para_id, data_id, cookies):
"""新增用户公共方法"""
# 获取请求url
url_insert = self.domain + Base.dh.get_path(para_id)
Log.info('insert user request url : {}'.format(url_insert))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 随机生成用户名
req_para['loginName'] = self.gene_username()
data_source[0][5] = req_para['loginName']
req_para['name'] = self.gene_username()
data_source[0][6] = req_para['name']
# 接口数据类型转换
req_para['group'] = eval(req_para['group'])
req_para['status'] = eval(req_para['status'])
Log.info('insert user request data is {}'.format(json.dumps(req_para)))
# 请求接口
res = requests.post(url=url_insert,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('insert user response data is {}'.format(res))
# 结果检查
actual = self.check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_get_list(self, para_id, data_id, cookies, flag):
"""历史记录--查询协同计算列表公共方法"""
# 获取请求url
url_get_list = self.domain + Base.dh.get_path(para_id)
Log.info('get_list request url : {}'.format(url_get_list))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 请求数据转换
for key in req_para.keys():
if key == 'remark' or key == 'target':
pass
elif req_para[key] == '':
pass
else:
req_para[key] = eval(req_para[key])
Log.info('get_list request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_list,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_list response data is {}'.format(res))
# 结果检查
actual = self.get_list_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_download_log_file(self, para_id, data_id, cookies, flag=True):
"""日志部分-下载log文件"""
# 获取请求url
url_download_task = self.domain + Base.dh.get_path(para_id)
Log.info(
'download_log_file request url : {}'.format(url_download_task))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 查找task id
req_para['userId'] = self.get_user_id(req_para['userId'])
data_source[0][5] = req_para['userId']
Log.info('download_log_file request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_download_task,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para))
Log.info('download_log_file response data is {}'.format(
res.status_code))
# 结果检查
actual = self.new_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_download_public_history(self,
para_id,
data_id,
cookies,
flag=True):
"""历史记录—（批量）下载excel"""
# 获取请求url
url_download_task = self.domain + Base.dh.get_path(para_id)
Log.info('download_public_history request url : {}'.format(
url_download_task))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 查找task id
req_para['taskIdList'] = self.get_history_task_id(
eval(req_para['taskIdList']))
data_source[0][5] = req_para['taskIdList']
Log.info('download_public_history request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_download_task,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para))
Log.info('download_public_history response data is {}'.format(
res.status_code))
# 结果检查
actual = self.new_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def test03_customer_edit_info(self):
print("修改客户从客户详情点击编辑case")
elemt = Base(self.driver)
Homepage(self.driver).customer_line()
time.sleep(2)
Customer_basic_location(self.driver).set_customer_basic_info(
"info" + Random_chinese) #填写客户信息
Customer_basic_location_edit(
self.driver).set_customer_basic_info_edit() #获取客户名称
Customer_basic_location(self.driver).new_customer_info_save() #保存客户
Customer_basic_location(self.driver).new_customer_info_check() #校验保存成功
Customer_basic_location_edit(
self.driver).set_customer_basic_select() #搜索客户名
Customer_select_list(self.driver).customer_list_name() #点击客户名称按钮
time.sleep(2)
Customer_basic_location_edit(
self.driver).edit_customer_info() #点击客户详情页面编辑
Customer_basic_location_edit(self.driver).edit_customer_basic_info(
"edit_info" + Random_chinese) #编辑客户信息
Customer_basic_location_edit(
self.driver).edit_customer_class_basic_info(
"editcls_info" + Random_chinese) #编辑客户分类
Customer_basic_location_edit(
self.driver).edit_address_button() #点击编辑地址按钮
Address_basic_location(self.driver).set_address_basic_info(
"客户信息页面进入修改地址备注！！！") #填写地址信息
elemt.screenshot("客户详情页面修改地址截图") # 截图
Address_basic_location(self.driver).address_basic_info_save() #保存地址
Customer_basic_location_edit(
self.driver).edit_customer_info_save() #保存客户
Customer_basic_location_edit(
self.driver).edit_customer_info_check() #校验保存成功
def base_update_user(self, para_id, data_id, cookies):
"""修改用户公共方法"""
# 获取请求url
url_update = self.domain + Base.dh.get_path(para_id)
Log.info('update user request url : {}'.format(url_update))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 随机生成用户名
req_para['userId'] = self.s.select_dic_single(
self.sql_select_update)['id']
data_source[0][5] = req_para['userId']
# 接口数据类型转换
req_para['group'] = eval(req_para['group'])
req_para['status'] = eval(req_para['status'])
Log.info('update user request data is {}'.format(json.dumps(req_para)))
# 检查数据库
self.before_update()
# 请求接口
res = requests.post(url=url_update,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('update user response data is {}'.format(res))
# 结果检查
actual = self.after_update_check(res=res, status=req_para['status'])
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def __init__(self, node=1, path_id=1):
self.node = node
Base.__init__(self, node=self.node, path_id=path_id)
self.node_o = 2 if self.node == 1 else 1
# self.fh = FileHandle(node=self.node)
# 本端数据库
self.con_n = sql(node=self.node)
def base_get_gwasgen_cal_result(self, para_id, data_id, cookies, flag):
"""历史记录-查询GWAS-基因型计算结果公共方法"""
# 获取请求url
url_get_gwasgen_cal_result = self.domain + Base.dh.get_path(para_id)
Log.info('get_gwasgen_maf_result request url : {}'.format(
url_get_gwasgen_cal_result))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 查询数据库taskId，随机选择查询
req_para['taskId'] = self.get_gwasgen_done_task_id()
req_para['pageNo'] = eval(req_para['pageNo'])
req_para['pageSize'] = eval(req_para['pageSize'])
data_source[0][5] = req_para['taskId']
# 数据库查询taskId为空处理
if req_para['taskId'] is None:
actual = not flag
Log.error('数据库查询taskId为空，该用例未执行，失败')
else:
Log.info(
'get_gwasgen_cal_result request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_gwasgen_cal_result,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_gwasgen_cal_result response data is {}'.format(res))
# 结果检查
actual = self.get_gwasgen_result_check(req_para['taskId'], res,
flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_get_user_by_id(self, para_id, data_id, cookies):
"""查询用户详情"""
# 获取请求url
url_get_user_by_id = self.domain + Base.dh.get_path(para_id)
Log.info('get_user_by_id request url : {}'.format(url_get_user_by_id))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
sql = 'SELECT id FROM t_user WHERE loginName = \'Automation\''
# 设置 userid
req_para['userId'] = self.s.select_single(sql)
data_source[0][5] = req_para['userId']
Log.info('get_user_by_id request data : {}'.format(req_para))
# 请求
res = requests.post(url=url_get_user_by_id,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_user_by_id response data is {}'.format(res))
# 结果检查
actual = self.check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def test03_vendor_edit_info(self):
print("修改供应商从供应商详情点击编辑case")
elemt = Base(self.driver)
Homepage(self.driver).vendor_line()
time.sleep(2)
Vendor_basic_location(self.driver).set_vendor_basic_info(
"info" + Random_chinese) # 填写供应商信息
Vendor_basic_location_edit(
self.driver).set_vendor_basic_info_edit() # 获取供应商名称
Vendor_basic_location(self.driver).new_vendor_info_save() # 保存供应商
Vendor_basic_location(self.driver).new_vendor_info_check() # 校验保存成功
Vendor_basic_location_edit(
self.driver).set_vendor_basic_select() # 搜索供应商名
Vendor_select_list(self.driver).vendor_list_name() # 点击供应商名称按钮
time.sleep(2)
Vendor_basic_location_edit(
self.driver).edit_vendor_info() #点击供应商详情页面编辑按钮
Vendor_basic_location_edit(self.driver).edit_vendor_basic_info(
"edit_info" + Random_chinese) # 编辑供应商信息
Vendor_basic_location_edit(self.driver).edit_vendor_class_basic_info(
"editcls" + Random_chinese) # 编辑供应商分类
Vendor_basic_location_edit(
self.driver).edit_address_button() # 点击编辑地址按钮
Address_basic_location(self.driver).set_address_basic_info(
"供应商修改地址备注！！！") # 填写地址信息
elemt.screenshot("供应商修改地址截图") # 截图
Address_basic_location(self.driver).address_basic_info_save() # 保存地址
Vendor_basic_location_edit(
self.driver).edit_vendor_info_save() # 保存供应商
Vendor_basic_location_edit(
self.driver).edit_vendor_info_check() # 校验保存成功
def get_logic_check(self, res, flag):
code = '00000'
if flag and res['code'] != code:
Log.error('请求返回应该为成功，实际失败 {}'.format(res))
return 0
if not flag and res['code'] == code:
Log.error('异常用例请求返回应该为失败，实际成功 {}'.format(res))
return 1
if res["code"] != code:
Log.error('请求返回有误 {}'.format(res))
return 0
# 查询数据库服务器列表
sql_get_logic = 'select * from t_logic order by id'
data_database = self.con_n.select_dic(sql_get_logic)
# 列表中的字典元素按key排序
for i in range(len(data_database)):
data_database[i] = Base.order_dic_by_keys(data_database[i])
Log.info('数据库t_logic列表排序后：{}'.format(data_database))
# 列表元素按id升序排列
data_res = sorted(res['data'], key=lambda k: k['id'])
# 列表中的字典元素按key排序
for i in range(len(data_res)):
data_res[i] = Base.order_dic_by_keys(data_res[i])
Log.info('接口查询logic列表排序后：{}'.format(data_res))
if data_database == data_res:
Log.info('check success,result is 1')
return 1
Log.error('接口返回数据与数据库查询不一致!')
return 0
def base_modify_password(self, para_id, data_id, cookies):
"""用户修改密码公共方法"""
# 获取请求url
url_modify = self.domain + Base.dh.get_path(para_id)
Log.info('insert user request url : {}'.format(url_modify))
# 获取请求数据，md5
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
req_para['userId'] = self.get_user_id()
data_source[0][5] = req_para['userId']
req_para['password'] = Base.make_password(req_para['password'])
req_para['newPassword'] = Base.make_password(req_para['newPassword'])
Log.info('modify_password data is {}'.format(req_para))
# 请求前数据库检查
self.before_modify_check()
# 请求
res = requests.post(url=url_modify,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('modify_password response data is {}'.format(res))
# 结果检查
actual = self.modify_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_get_detail_by_accept(self, para_id, data_id, cookies):
"""协同计算-查询详情公共方法"""
# 获取请求url
url_get_detail_by_accept = self.domain + Base.dh.get_path(para_id)
Log.info('get_detail_by_accept request url : {}'.format(
url_get_detail_by_accept))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 查询数据库taskId，随机选择查询
req_para['taskId'] = self.get_task_id()
data_source[0][5] = req_para['taskId']
Log.info('get_detail_by_accept request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_detail_by_accept,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_detail_by_accept response data is {}'.format(res))
# 结果检查
actual = self.get_detail_by_accept_check(req_para['taskId'], res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def __init__(self, node=1, path_id=2):
""" @:param node 1: hongkong other:bulisiban
@:param p_id path id
"""
Base.__init__(self, node=node, path_id=path_id)
pass
def base_gen_status(self, para_id, data_id, cookies):
"""gen start gen计算发起.状态一致测试"""
# 获取请求url
url_gen_start = self.domain + Base.dh.get_path(para_id)
Log.info('gen_start request url : {}'.format(url_gen_start))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# fileList 字符串转列表
req_para['fileList'] = eval(req_para['fileList'])
req_para['fileList'] = self.gene_file_id_list(req_para['fileList'],
cookies)
data_source[0][5] = req_para['fileList']
# top 数据转换
req_para['top'] = eval(req_para['top'])
req_para['isPrint'] = eval(req_para['isPrint'])
Log.info('gen_start request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_gen_start,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('gen_start response data is {}'.format(res))
# 结果检查
status = eval(data_source[0][3])
actual = self.gen_status_check(res, status)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_reset_password(self, para_id, data_id, cookies):
"""admin重置用户密码"""
# 获取请求url
url_reset = self.domain + Base.dh.get_path(para_id)
Log.info('reset_password url is {}'.format(url_reset))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
sql = 'SELECT id FROM t_user WHERE loginName = \'Automation\''
# 设置 userid
req_para['userId'] = self.s.select_single(sql)
data_source[0][5] = req_para['userId']
Log.info('reset_password data is {}'.format(req_para))
# 请求前数据库检查
self.before_reset()
# 请求接口
res = requests.post(url=url_reset,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('reset_password response data is {}'.format(res))
# 结果检查
actual = self.after_reset_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_get_list_by_accept(self, para_id, data_id, cookies):
"""查询协同计算列表公共方法"""
# 获取请求url
url_get_list_by_accept = self.domain + Base.dh.get_path(para_id)
Log.info('get_list_by_accept request url : {}'.format(
url_get_list_by_accept))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 请求数据转换
if not req_para['calType'] == '':
req_para['calType'] = eval(req_para['calType'])
req_para['pageNo'] = eval(req_para['pageNo'])
req_para['pageSize'] = eval(req_para['pageSize'])
Log.info('get_list_by_accept request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_list_by_accept,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_list_by_accept response data is {}'.format(res))
# 结果检查
actual = self.get_list_by_accept_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def __init__(self, node=1, path_id=1):
self.node = node
self.s = sql(node=node)
Base.__init__(self, node=node, path_id=path_id)
# file 文件目录
self.file_path = os.path.join(
os.path.realpath(os.path.dirname(os.path.dirname(__file__))),
'data')
Log.info('上传文件所在目录：{}'.format(self.file_path))
def __init__(self, node=1, path_id=1):
""" @:param node 1: hongkong other:bulisiban
@:param p_id path id
"""
# self.headers = {'Content-Type': 'application/json;charset=UTF-8'}
self.path_id = path_id
Base.__init__(self, node=node, path_id=path_id)
# Log.info('login url is %s' % self.url)
pass
def __init__(self, node=1, path_id=1):
self.node = node
Base.__init__(self, node=self.node, path_id=path_id)
self.node_o = 2 if self.node == 1 else 1
# 本端数据库
self.con_n = sql(node=self.node)
# 对端数据库
self.con_o = sql(node=self.node_o)
def __init__(self, node=1, path_id=1):
""" @:param node 1: hongkong other:bulisiban
@:param p_id path id
"""
self.node = node
# self.cookies = Login(node=node, path_id=1).get_cookie()
self.s = sql(node=node)
Base.__init__(self, node=node, path_id=path_id)
pass
def __init__(self, node=1, path_id=1):
self.node = node
Base.__init__(self, node=self.node, path_id=path_id)
self.node_o = 2 if self.node == 1 else 1
# 文件上传接口para id
self.upload_para_id = 10
# gwas 文件类型 3
self.fileType = 3
self.fh = FileHandle(node=self.node)
# 本端数据库
self.con_n = sql(node=self.node)
# 对端数据库
self.con_o = sql(node=self.node_o)
def base_compute_gwas(self,
para_id,
data_id,
cookies,
calType=3,
maxFile=0):
"""vcf协同计算 calType:1 随机查找vcf task ; 2 查找基因协同计算任务 3 GWAS 0 查找最大id+6666"""
# 获取请求url
url_compute_gwas = self.domain + Base.dh.get_path(para_id)
Log.info('compute_gwas request url : {}'.format(url_compute_gwas))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
req_para['fileIdList'] = eval(req_para['fileIdList'])
# 登录态判断
if cookies is not None:
# 不存在的fileid
if maxFile:
req_para['fileIdList'] = self.get_max_file_id()
# fileIdList为空，不处理
elif len(req_para['fileIdList']) == 0:
pass
# file文件上传获取fileIdList
else:
req_para['fileIdList'] = self.gene_file_id_list(
req_para['fileIdList'], cookies)
# id不存在
if not calType:
req_para['taskId'] = self.get_max_task_id()
else:
req_para['taskId'] = self.get_task_id(calType)
data_source[0][5] = req_para['taskId']
data_source[0][6] = req_para['fileIdList']
Log.info('compute_gwas request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_compute_gwas,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('compute_gwas response data is {}'.format(res))
# 结果检查
actual = self.gwas_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def test01_customer_new(self):
print("客户新建case")
elemt = Base(self.driver)
Homepage(self.driver).customer_line()
time.sleep(2)
Customer_basic_location(self.driver).set_customer_basic_info(
"new" + Random_chinese) #填写客户信息
Customer_basic_location(self.driver).set_customer_class_info(
"newcls" + Random_chinese) #填写客户分类
Customer_basic_location(self.driver).new_address_button() #点击新建客户地址按钮
Address_basic_location(self.driver).set_address_basic_info(
"客户新增地址备注！！！") #填写地址信息
elemt.screenshot("客户新增地址截图") # 截图
Address_basic_location(self.driver).address_basic_info_save() #保存地址
Customer_basic_location(self.driver).new_customer_info_save() #保存客户
Customer_basic_location(self.driver).new_customer_info_check() #校验保存成功
def setUp(self):
self.driver = webdriver.Chrome()
self.driver.maximize_window()
time.sleep(2)
self.driver.get('http://66.3.17.180:8001/login.html')
self.base = Base(self.driver)
self.ver = Version_manage(self.driver)
def test01_vendor_new(self):
print("新建供应商case")
elemt = Base(self.driver)
Homepage(self.driver).vendor_line()
time.sleep(2)
Vendor_basic_location(self.driver).set_vendor_basic_info(
"new" + Random_chinese) #填写供应商信息
Vendor_basic_location(self.driver).set_vendor_class_info(
"newclas" + Random_chinese) #填写供应商分类
Vendor_basic_location(self.driver).new_address_button() # 点击新建供应商地址按钮
Address_basic_location(self.driver).set_address_basic_info(
"客户新增地址备注！！！") # 填写地址信息
elemt.screenshot("供应商新增地址截图") # 截图
Address_basic_location(self.driver).address_basic_info_save() # 保存地址
Vendor_basic_location(self.driver).new_vendor_info_save() # 保存供应商
Vendor_basic_location(self.driver).new_vendor_info_check() # 校验保存成功
def base_gen_start(self, para_id, data_id, cookies, isChange=0, maxFile=0):
"""gen start gen计算发起. isChange:0读取请求数据，1 请求数据重复100遍"""
# 获取请求url
url_gen_start = self.domain + Base.dh.get_path(para_id)
Log.info('gen_start request url : {}'.format(url_gen_start))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 登录态判断
if cookies is not None:
# 不存在的fileid
if maxFile:
req_para['fileList'] = self.get_max_file_id()
data_source[0][5] = req_para['fileList']
else:
# fileList 字符串转列表
req_para['fileList'] = eval(req_para['fileList'])
# fileList 文件上传，获取文件id,如果文件列表为空，则跳过上传文件操作
if len(req_para['fileList']) > 0:
req_para['fileList'] = self.gene_file_id_list(
req_para['fileList'], cookies)
data_source[0][5] = req_para['fileList']
else:
pass
# remark 内容
if isChange:
req_para['remark'] = req_para['remark'] * 100
data_source[0][7] = req_para['remark']
# top 数据转换
req_para['top'] = eval(req_para['top'])
req_para['isPrint'] = eval(req_para['isPrint'])
Log.info('gen_start request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_gen_start,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('gen_start response data is {}'.format(res))
# 结果检查
actual = self.gen_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_compute_mul(self,
para_id,
data_id,
cookies,
flag,
maxId=0,
maxFile=0):
"""vcf 批量计算"""
# 获取请求url
url_compute_mul = self.domain + Base.dh.get_path(para_id)
Log.info('compute_mul request url : {}'.format(url_compute_mul))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 登录态判断
if cookies is not None:
# 不存在的fileid
if maxFile:
req_para['fileId'] = self.get_max_file_id()
else:
# file文件上传获取fileId
req_para['fileId'] = self.gene_file_id(req_para['fileId'],
cookies)
# taskId
if maxId:
req_para['taskId'] = self.get_vcf_max_task_id()
else:
req_para['taskId'] = self.get_vcf_task_id_list()
data_source[0][5] = req_para['taskId']
data_source[0][7] = req_para['fileId']
Log.info('compute_vcf request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_compute_mul,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('compute_vcf response data is {}'.format(res))
# 结果检查
actual = self.vcf_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def test04_sales_copy(self):
elemt = Base(self.driver)
Homepage(self.driver).sales_line()
time.sleep(1)
Sales_info_case(self.driver).sales_new_info()
time.sleep(1)
Homepage(self.driver).sales_line()
time.sleep(2)
Sales_info_case(self.driver).sales_copy_info()
def base_logout(self, para_id, data_id, cookies=None):
"""退出登录公共方法"""
Log.info('logout url is %s' % self.url)
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('request data is %s' % req_para)
# 请求接口
res = requests.post(url=self.url, headers=Base.headers, cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('logout response data is {}'.format(res))
# 结果检查
actual = self.check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
