class DependentData(object):
def __init__(self, case_id):
self.opexcel = OperationExcel()
self.getdata = GetData()
self.case_id = case_id
self.runmethod = RunMethod()
def get_case_line_data(self):
row_data = self.opexcel.from_case_id_get_row_data(self.case_id)
return row_data
def rundependent(self):
row_num = self.opexcel.from_case_id_get_row_num(self.case_id)
request_data = self.getdata.get_data_for_json(row_num)
url = self.getdata.get_url(row_num)
method = self.getdata.get_request_method(row_num)
header = self.getdata.is_header(row_num)
res = self.runmethod.run_main(url, method, request_data, header)
return res
#在依赖response中查找依赖数据
def get_data_for_key(self, row):
depend_data = self.getdata.get_data_depend(row)
response_data = self.rundependent()
print(depend_data)
print("************************")
print(response_data)
p_depend_data = parse(depend_data)
madle = p_depend_data.find(response_data)
return [math.value for math in madle][0]
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.common_util = CommonUtil()
self.send_email = SendEmail()
self.excel = OperationExcel()
self.sheet_obj = self.excel.get_data()
class DependentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GerData()
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependent(self):
httpclient = HttpClient()
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
#header = self.data.is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
result = httpclient.request(method, url, request_data)
return json.loads(result)
#根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
print(type(depend_data), "depend_data:", depend_data)
print(type(response_data), "response_data:", response_data)
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
return [math.value for math in madle][0]
def __init__(self, request_data, case_depend: list, data_depend: list,
filed_depend: list):
"""
:param case_depend: ['sheet_name','case_id']
:param data_depend: ['store.book.[2].title','store.book.[3].title']
:param filed_depend:['parent_key2.[0].child_key11','parent_key2.[1].child_key22']
"""
self.request_data = request_data
self.case_depend = case_depend
self.sheet_name = self.case_depend[0]
self.case_id = self.case_depend[1]
self.data_depend = data_depend
self.filed_depend = filed_depend
self.operation_excel = OperationExcel()
self.data = GetData()
def __init__(self):
# self.case_id = case_id
self.get_data = GetData()
self.run_method = RunMethod()
self.com_util = CommonUtil()
self.opera_excel = OperationExcel()
def __init__(self):
self.opera_excel = OperationExcel()
self.sheet = self.opera_excel.get_data()
class GetData():
def __init__(self, filename=None, sheet_id=None):
self.opera_excel = OperationExcel(filename, sheet_id)
self.com_util = CommonUtil()
self.op_excel_value = op_excel_value.OpValue()
self.get_conf = GetConf()
def trans_value(self, v):
return self.com_util.value_trans(v)
# 获取当前 sheet name
def get_current_sheet_name(self):
return self.trans_value(self.opera_excel.get_sheet_name())
# 获取excel行数
def get_case_lines(self):
return self.trans_value(self.opera_excel.get_sheet_rows_num())
# 通过caseidname 获取行号
def get_case_row_by_idname(self, idname):
col_num = 1
for i in self.opera_excel.get_col_value(1):
if idname == i:
return col_num
col_num += 1
return False
# 获取case id
def get_case_id_name(self, row):
col = data_config.get_id_col()
case_id = self.opera_excel.get_cell_value(row, col)
if case_id:
return self.trans_value(case_id)
else:
return ""
#获取模块名称
def get_mod_name(self, row):
col = data_config.get_modname_col()
modname = self.opera_excel.get_cell_value(row, col)
return self.trans_value(modname)
#获取api接口名称
def get_apiname(self, row):
col = data_config.get_apiname_col()
apiname = self.opera_excel.get_cell_value(row, col)
return self.trans_value(apiname)
#获取url 请求地址
def get_url(self, row):
col = data_config.get_url_col()
url = self.opera_excel.get_cell_value(row, col)
if url:
return self.trans_value(url)
else:
return ""
def get_url_final(self, row):
url = self.get_url(row)
if url:
url = str(
self.get_conf.read_conf_value_toexcel("urlprefix")).replace(
'"', '') + str(url)
return url
# 是个否运行
def get_is_run(self, row):
flag = None
col = data_config.get_run_col()
is_run = self.opera_excel.get_cell_value(row, col)
if str(is_run).lower() == "yes" or str(is_run).lower() == "y":
flag = True
else:
flag = False
return self.trans_value(flag)
# 获取请求的方式
def get_request_method(self, row):
col = data_config.get_request_method_col()
method = self.opera_excel.get_cell_value(row, col)
return self.trans_value(method)
#获取 cookie值
def get_is_cookie(self, row):
col = data_config.get_cookie_col()
is_cookie = self.opera_excel.get_cell_value(row, col)
return self.trans_value(is_cookie)
# # 是否携带 header
# def get_is_header(self, row):
# col = data_config.get_header_col()
# is_header = self.opera_excel.get_cell_value(row, col)
# if str(is_header).lower() == "yes":
# return self.trans_value(data_config.get_header_info())
# else:
# return None
##获取header值
def get_header_info(self, row):
col = data_config.get_header_col()
headerinfo = self.opera_excel.get_cell_value(row, col)
if str(headerinfo) == "" or headerinfo == None:
return {}
else:
return json.loads(headerinfo)
# 获取 dependent caseid name
def get_dependent_caseid(self, row):
col = data_config.get_dependent_caseid_col()
caseid = self.opera_excel.get_cell_value(row, col)
if caseid == "":
return None
else:
return caseid
# 获取dependent data 内容
def get_dependent_data(self, row):
col = data_config.get_dependent_data_col()
dependent_data = self.opera_excel.get_cell_value(row, col)
return dependent_data
# 获取depent filed字段内容
def get_dependent_filed(self, row):
col = data_config.get_dependent_filed_col()
filed_data = self.opera_excel.get_cell_value(row, col)
return filed_data
# 获取请求数据
def _get_request_data(self, row):
col = data_config.get_request_data_col()
data = self.opera_excel.get_cell_value(row, col)
if data == "":
return None
return self.trans_value(data)
# 通过关键字拿到 请求体，request_data数据
def get_request_data_final(self, row):
request_data = self._get_request_data(row) #请求数据，关键字
if str(request_data).startswith("json_"): #如果json_开头则进行json获取
opera_json = OperationJson()
request_data = opera_json.get_value(request_data)
return self.trans_value(request_data)
elif str(request_data) != "":
request_data = self.op_excel_value.replace_value(
request_data) # 更新替换excel请求中带的变量
return self.trans_value(
request_data) #如果不为空，不是json_开头，那么就替换变量再返回数据
else:
return None #没有请求数据，则返回None
#保存响应中的指定值（json获取方式）
def get_save_value(self, row):
col = data_config.get_save_value_col()
savevalue = self.opera_excel.get_cell_value(row, col)
if str(savevalue) == "" or savevalue == None:
return None
else:
return str(savevalue)
# 获取预期响应结果
def _get_expect_result(self, row):
col = data_config.get_expect_result_col()
expect_value = self.opera_excel.get_cell_value(row, col)
if expect_value == "":
return None
return self.trans_value(expect_value)
def get_expect_result_final(self, row):
'''
获取预期结果，返回数组类型
:param row:
:return: type:list
'''
expect_result = self._get_expect_result(row)
if str(expect_result).startswith("json_"): # 如果json_开头则进行json获取
opera_json = OperationJson()
expect_data = opera_json.get_value(expect_result)
print('通过json配置的预期结果断言###值为：', expect_data)
return list(str(self.trans_value(expect_data)).split(','))
elif str(expect_result) != "":
expect_data = self.op_excel_value.replace_value(
expect_result) # 更新替换excel请求中带的变量
return list(str(self.trans_value(expect_data)).split(
',')) # 如果不为空，不是json_开头，那么就替换变量再返回数据
elif str(expect_result) == "" or expect_result == None:
return [] # 没有请求数据，则返回None
else:
return ["ERROR_FOUND_EXPECT_RESULT"]
#获取预期响应code
def get_expect_code(self, row):
col = data_config.get_except_code_col()
expect_code = self.opera_excel.get_cell_value(row, col)
if expect_code == "":
return 200
return self.trans_value(expect_code)
#获取数据库校验语句
def get_dbcheck_sql(self, row):
col = data_config.get_dbcheck_col()
dbchecksql = self.opera_excel.get_cell_value(row, col)
if str(dbchecksql) != "" or str(dbchecksql) != None:
return str(dbchecksql)
else:
return None
#获取备注信息
def get_comment_info(self, row):
col = data_config.get_comment_col()
commentinfo = self.opera_excel.get_cell_value(row, col)
if str(commentinfo) != "" or str(commentinfo) != None:
return str(commentinfo)
else:
return ""
# 判断是否需要 依赖case
def get_is_dependent(self, row):
data = self.get_dependent_caseid(row)
if data:
return True
else:
return False
#写 当前结果到excel
def write_current_result(self, row, value):
col = data_config.get_current_result_col()
writevalue = self.opera_excel.write_cell_value(row, col, value)
if writevalue:
return True
else:
return False
#写 当前响应code到excel
def write_current_code(self, row, value):
col = data_config.get_current_code_col()
writevalue = self.opera_excel.write_cell_value(row, col, value)
if writevalue:
return True
else:
return False
#写 测试结果到excel
def write_test_result(self, row, value):
col = data_config.get_test_result_col()
## row,col,value,result(通过value来判断pass,fail,else 用于写不同的颜色)
writevalue = self.opera_excel.write_cell_value(row,
col,
value,
result=value)
if writevalue:
return True
else:
return False
def __init__(self, filename=None, sheet_id=None):
self.opera_excel = OperationExcel(filename, sheet_id)
self.com_util = CommonUtil()
self.op_excel_value = op_excel_value.OpValue()
self.get_conf = GetConf()
class DependentData:
def __init__(self, request_data, case_depend: list, data_depend: list,
filed_depend: list):
"""
:param case_depend: ['sheet_name','case_id']
:param data_depend: ['store.book.[2].title','store.book.[3].title']
:param filed_depend:['parent_key2.[0].child_key11','parent_key2.[1].child_key22']
"""
self.request_data = request_data
self.case_depend = case_depend
self.sheet_name = self.case_depend[0]
self.case_id = self.case_depend[1]
self.data_depend = data_depend
self.filed_depend = filed_depend
self.operation_excel = OperationExcel()
self.data = GetData()
def update_json_data(self, key_expr: str, value: str):
"""
将提取到的结果更新到 请求头 数据当中
:param key_expr:请求头数据的key 'parent_key2.[0].child_key11'
:param value: 从响应结果中获取到的值
:return:
"""
key = key_expr.split(".")
key_length = len(key)
get_json_data = self.request_data
counter = 0
while counter < key_length:
key_value = key[counter]
if key_value.startswith('[') and key_value.endswith(']'):
key_value = eval(key_value[1:-1])
if counter + 1 == key_length:
get_json_data[key_value] = value
else:
get_json_data = get_json_data[key_value]
counter = counter + 1
return self.request_data
def run_dependent(self):
"""执行依赖测试，获取结果"""
# 通过sheet页名称读取对应sheet页的数据
self.data.get_sheet_data(self.sheet_name)
# 通过sheet_name和case_id获取行号
row_num = self.operation_excel.get_rowNum_by_sheetName_and_caseId(
self.sheet_name, self.case_id)
url = self.data.get_request_url(row_num)
method = self.data.get_request_method(row_num)
request_data = self.data.get_request_data(self.sheet_name, row_num)
headers = self.data.get_is_header(row_num)
cookies = self.data.get_is_cookie(row_num)
run_method = RunMethod()
res = run_method.run_method(method, url, request_data, headers,
cookies)
return json.loads(res)
def get_data_for_key(self):
"""根据依赖的key去获取执行依赖的case的响应，然后返回响应数据"""
# 执行依赖测试，获取结果
response_data = self.run_dependent()
for request_key, response_key in zip(self.filed_depend,
self.data_depend):
json_path_expr_value = parse(response_key)
# 根据依赖数据的json_path表达式从响应结果中提取依赖值
var_value = [
match.value
for match in json_path_expr_value.find(response_data)
][0]
# 将提取到的结果更新到 请求头 数据当中
self.request_data = self.update_json_data(request_key, var_value)
return self.request_data
class DependentData:
def __init__(self,case_id):
self.case_id=case_id
self.opera_excel=OperationExcel()
self.datas=GetData()
self.gettime=GetTime()
def get_case_line_data(self):
rows_data=self.opera_excel.get_rows_data(self.case_id) #根据caseid获取excel整行数据
def run_dependent(self):
row_num=self.opera_excel.get_rows_num(self.case_id)
url = self.datas.get_request_url(row_num)
# print(url)
method = self.datas.get_request_method(row_num)
# print(method)
headers = self.datas.get_header_for_json(row_num)
# print(headers)
# print(type(headers))
data = self.datas.get_data_for_json(row_num)
# print(data)
# 获取预期结果值
#excepts = self.datas.get_except_val(row_num)
# 延迟发送
times = self.datas.get_delaytime_mm(row_num)
self.gettime.delaytime(times)
# 获取cookies
cookies = self.datas.get_is_cookie(row_num)
if cookies != None:
if cookies != "write":
# 发送请求
# print(headers)
res = RunQuest(url, method, data, headers, cookies).res
return res
res = RunQuest(url, method, data, headers).res
#res=json.loads(res)
return res
#只根据依赖请求
def get_is_req_sucess(self):
res=self.run_dependent()
time.sleep(1)
print(self.case_id+"依赖请求:"+str(res))
#根据依赖的key 获取依赖的case的响应中的值
def get_data_for_key(self,row):
depend_data=self.datas.get_depend_key(row) #获取响应依赖的数据
depend_data=depend_data.split(":")
res_data=self.run_dependent() #获取响应的值
if isinstance(res_data, dict): # 判断是否请求成功
# json_exe=parse(depend_data)
# madle=json_exe.find(res_data)
# return [math.value for math in madle][0]
for_key_value=self.get_for_key(res_data,depend_data)
if for_key_value !=None:
return for_key_value
else:
return None
else:
return None
def get_for_key(self,res_data, *keys):
res_datas = res_data
for ks in keys:
for k in ks:
#print(k)
res_datas = self.get_for_key_value(res_datas, k)
# print(res_datas)
# print(res_datas)
return res_datas
#判断是否存在
def get_for_key_value(self,res_data, depend_data):
try:
json_exe = parse(depend_data)
# print(json_exe)
madle = json_exe.find(res_data)
# print(madle)
# print(type(madle))
datas = [math.value for math in madle][0]
#print(datas)
# print(type(datas))
return datas
except:
return None
def __init__(self):
self.data = OperationExcel()
self.dataconfig = GlobalVar()
class DependentData(object):
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
self.run_method = RunMethod()
'''通过case_id去获取该case_id的整行数据'''
def get_case_line_data(self):
try:
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
except Exception as e:
logging.info("错误为：", e)
'''执行依赖测试，获取结果'''
def run_dependent(self):
try:
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
header = self.data.is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
res = self.run_method.run_main(method, url, request_data, header)
# return res
return json.loads(res)
except Exception as e:
logging.info("错误为：", e)
'''根据依赖的key去获取执行依赖测试case的响应，
然后返回,都要为字典格式,所以将上面的run_dependent函数的结果以字典的格式返回'''
def get_data_for_key(self, row):
try:
# rows.[0].productID
# depend_data是依赖的返回数据 rows.[0].productID
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
return [math.value for math in madle][0]
except Exception as e:
logging.info("错误为：", e)
dic = {}
# 把依赖数据保存到文件里
def save_depend_value(self, res, depend_data, dict_key):
res = json.loads(res)
depend_data = list(depend_data.split(","))
dict_key = list(dict_key.split(","))
for i in range(len(dict_key)):
try:
json_exe = parse(depend_data[i])
madle = json_exe.find(res)
value = [math.value for math in madle][0]
with open(depend_data_path, 'r', encoding='utf-8') as f:
depend_value = f.read()
if depend_value == "":
depend_value = "{}"
depend_value = json.loads(depend_value)
key = dict_key[i]
depend_value[key] = value
except IndexError as e:
logging.info("错误为：", e)
finally:
try:
with open(depend_data_path, 'w', encoding='utf-8') as f:
depend_value = json.dump(depend_value, f)
f.flush()
except Exception as e:
logging.info("错误为：", e)
# _*_ coding: utf-8 _*_
# @Time : 2020/4/9 19:54
# @Author : Daisy
# @File : test_login_books.py
import json
import pytest
from base.method import RequestMethod
from utils.operation_excel import OperationExcel, ExcelColumNameAll
from common.public import write_id_to_file, read_id_from_file
excel = OperationExcel(file_name='books_all.xlsx', file_dir='data')
rqst = RequestMethod()
print(excel.read_excel_data())
def get_dict(data, col_name):
'''对请求参数/请求头为空进行处理，并把字符串转换成dict类型'''
param = data[col_name]
if len(param.strip()) == 0:
pass
else:
return json.loads(param.strip()) # 反序列化，得到字典类型
def get_url(data, book_id):
"""如果要获取某本书籍信息，则需要替换bookID的值；否则获取全部书籍信息"""
if book_id:
url = data[ExcelColumNameAll.rqst_url].replace('{bookID}', book_id)
else:
url = data[ExcelColumNameAll.rqst_url]
class GetData:
def __init__(self):
self.data = OperationExcel()
self.dataconfig = GlobalVar()
#获取总行数
def get_case_lines(self):
return self.data.get_rows()
#获取是否执行case
def get_is_run(self, row):
flag = None
col = self.dataconfig.get_run()
runvalue = self.data.get_value(row, int(col))
if runvalue == "yes":
flag = True
else:
flag = False
return flag
# 获取获取header关键词
def get_req_header(self, row):
col = self.dataconfig.get_header()
headervalue = self.data.get_value(row, int(col))
if headervalue == "":
return None
return headervalue
# if headervalue == "yes":
# return self.dataconfig.get_header_value()
# else:
# return None
# 根据关键词获取请求header的json内容
def get_header_for_json(self, row):
if self.get_req_header(row) != None:
for_json = OperationJson(filename="../dataconfig/header.json")
req_header = for_json.get_data(self.get_req_header(row))
return req_header
else:
return None
#获取是否获取cookie
def get_is_cookie(self, row):
col = self.dataconfig.get_cookies()
cookievalue = self.data.get_value(row, int(col))
if cookievalue == "write":
return cookievalue
elif cookievalue == "yes":
self.getcookie = GetCookie()
return self.getcookie.read_data() #读取cookie
else:
return None
#获取请求方式
def get_request_method(self, row):
col = self.dataconfig.get_method()
req_methods = self.data.get_value(row, int(col))
return req_methods
#获取请求url
def get_request_url(self, row):
col = self.dataconfig.get_url()
req_url = self.data.get_value(row, int(col))
return req_url
#获取请求数据的josn关键词
def get_request_data(self, row):
col = self.dataconfig.get_data()
req_data = self.data.get_value(row, int(col))
if req_data == "":
return None
return req_data
#根据关键词获取请求数据的json内容
def get_data_for_json(self, row):
ecl_data = self.get_request_data(row)
if self.get_request_data(row) != None:
datas = ecl_data.split(":")
if len(datas) > 1:
for_json = OperationJson("../dataconfig/" + datas[0] + ".json")
req_data = for_json.get_data(datas[1])
return req_data
else:
print("请求数据格式不对!格式必须为 filename:jsonname")
return None
else:
return None
#获取预期结果
def get_except_val(self, row):
col = self.dataconfig.get_except()
req_except = self.data.get_value(row, int(col))
if req_except == "":
return None
return req_except
#获取返回响应的依赖数据的key
def get_depend_key(self, row):
col = int(self.dataconfig.get_data_depend()) #获取列
depend_key = self.data.get_value(row, col)
if depend_key == "":
return None
else:
return depend_key
#判断是否有case依赖 获取依赖的case
def is_depend(self, row):
col = int(self.dataconfig.get_case_depend()) # 获取列
depend_case_id = self.data.get_value(row, col)
if depend_case_id == "":
return None
else:
return depend_case_id
# 获取请求数据的依赖key
def get_depend(self, row):
col = int(self.dataconfig.get_field_depend()) # 获取列
data = self.data.get_value(row, col)
if data == "":
return None
else:
return data
# 获取请求数据的依赖key
def get_header_depend(self, row):
col = int(self.dataconfig.get_header_depend()) # 获取列
headers = self.data.get_value(row, col)
if headers == "":
return None
else:
return headers
#写入实际结果
def write_result(self, row, value):
col = int(self.dataconfig.get_result())
self.data.write_value(row, col, value)
# 写入更新时间
def write_update_time(self, row, value):
col = int(self.dataconfig.get_update_time())
self.data.write_value(row, col, value)
#获取请求延迟时间 毫秒
def get_delaytime_mm(self, row):
col = int(self.dataconfig.get_delaytime())
delayvalue = self.data.get_value(row, int(col))
if delayvalue == "":
return None
else:
return delayvalue
#获取短信验证码
def get_sms_value(self, cellphone):
sql = "select code from driver_oauth where cellphone=" + cellphone
self.dbs = ConnectDb()
self.dbs.get_sms_db()
sms = self.dbs.get_data_one(sql)
print(sms)
return sms
def __init__(self, filename=None, sheet_id=None):
self.opera_excel = OperationExcel(filename, sheet_id)
class GetData(object):
def __init__(self, filename=None, sheet_id=None):
self.opera_excel = OperationExcel(filename, sheet_id)
def get_case_lines(self):
return self.opera_excel.get_lines()
def get_is_run(self, row):
flag = None
col = data_config.global_val.get_run()
run_model = self.opera_excel.get_cell_value(row, int(col))
if run_model == 'yes':
flag = True
else:
flag = False
return flag
def is_cookie(self, row):
col = data_config.global_val.get_cookie()
cookie = self.opera_excel.get_cell_value(row, int(col))
return cookie
def is_header(self, row):
col = data_config.global_val.get_header()
header = self.opera_excel.get_cell_value(row, int(col))
if header == 'yes':
return data_config.global_val.get_header_value()
else:
return None
def get_request_method(self, row):
col = data_config.global_val.get_request_way()
request_method = self.opera_excel.get_cell_value(row, int(col))
return request_method
def get_url(self, row):
col = data_config.global_val.get_url()
url = self.opera_excel.get_cell_value(row, int(col))
return url
def get_request_data(self, row):
col = data_config.global_val.get_data()
data = self.opera_excel.get_cell_value(row, int(col))
if data == '':
return None
else:
return data
def get_data_for_json(self, row):
self.opera_json = OperationJson()
data_json = self.opera_json.get_data(self.get_request_data(row))
return data_json
def get_expect(self, row):
col = data_config.global_val.get_expect()
expect = self.opera_excel.get_cell_value(row, int(col))
if expect == '':
return None
else:
return expect
def write_result(self, row, value):
col = data_config.global_val.get_result()
self.opera_excel.write_value(row, int(col), value)
def get_data_depend(self, row):
col = data_config.global_val.get_data_depend()
data_depend = self.opera_excel.get_cell_value(row, int(col))
if data_depend == "":
return None
else:
return data_depend
def is_depend(self, row):
col = data_config.global_val.get_case_depend()
case_depend = self.opera_excel.get_cell_value(row, int(col))
if case_depend is not None:
return case_depend
else:
return None
def get_field_depend(self, row):
col = data_config.global_val.get_field_depend()
field_depend = self.opera_excel.get_cell_value(row, int(col))
if field_depend is not None:
return field_depend
else:
return None
def __init__(self,case_id):
self.case_id=case_id
self.opera_excel=OperationExcel()
self.datas=GetData()
self.gettime=GetTime()
class GetData(object):
def __init__(self):
self.opera_excel = OperationExcel()
self.sheet = self.opera_excel.get_data()
'''获取excel的行数，就是我们的case个数'''
def get_case_lines(self):
try:
return self.opera_excel.get_lines()
except Exception as e:
logging.info("错误为：", e)
'''获取是否执行'''
def get_is_run(self, row):
try:
flag = None
col = get_run()
run_model = self.opera_excel.get_cell_value(row, col)
if run_model == 'y':
flag = True
else:
flag = False
return flag
except Exception as e:
logging.info("错误为：", e)
'''获取接口描述'''
def get_api_msg(self, row):
try:
col = get_request_name()
api_msg = self.opera_excel.get_cell_value(row, col)
return api_msg
except Exception as e:
logging.info("错误为：", e)
'''获取接口名称'''
def get_api_name(self, row):
try:
col = get_api_name()
api_name = self.opera_excel.get_cell_value(row, col)
return api_name
except Exception as e:
logging.info("错误为：", e)
'''是否携带header'''
def get_request_headers(self, row):
try:
col = get_header()
header = self.opera_excel.get_cell_value(row, col)
if header == '':
return None
return header
except Exception as e:
logging.info("错误为：", e)
'''是否有header'''
def is_header(self, row):
try:
col = get_header()
header = self.opera_excel.get_cell_value(row, col)
if header != 'n':
header = json.loads(header)
return header
# return self.opera_excel.get_cell_value(row,col)
elif header == 'w':
return 'w'
else:
return None
except Exception as e:
logging.info("错误为：", e)
'''获取请求方式'''
def get_request_method(self, row):
try:
col = get_run_way()
request_method = self.opera_excel.get_cell_value(row, col)
return request_method
except Exception as e:
logging.info("错误为：", e)
'''获取url'''
def get_request_url(self, row):
try:
col = get_url()
url = self.opera_excel.get_cell_value(row, col)
return url
except Exception as e:
logging.info("错误为：", e)
'''请求数据'''
def get_request_data(self, row):
try:
col = get_data()
data = self.opera_excel.get_cell_value(row, col)
if data == '':
return None
return data
except Exception as e:
logging.info("错误为：", e)
'''通过获取关键字拿到data数据'''
def get_data_for_json(self, row):
try:
opera_json = OperationJson()
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
except Exception as e:
logging.info("错误为：", e)
'''获取要提取的字段的值'''
def get_depend_value(self, row):
try:
col = get_depend_value()
depend_value = self.opera_excel.get_cell_value(row, col)
if depend_value == '':
return None
return depend_value
except Exception as e:
logging.info("错误为：", e)
'''获取预期结果'''
def get_expect_data(self, row):
try:
col = get_expect()
expect = self.opera_excel.get_cell_value(row, col)
if expect == '':
return None
return expect
except Exception as e:
logging.info("错误为：", e)
'''获取http状态码'''
def get_http_code_data(self, row):
try:
col = get_http_code()
http_code = self.opera_excel.get_cell_value(row, col)
return http_code
except Exception as e:
logging.info("错误为：", e)
'''获取待替换的值'''
def get_waiting_replace_key(self, row):
try:
col = get_waiting_replace_key()
wait_rep_key = self.opera_excel.get_cell_value(row, col)
if wait_rep_key == '':
return None
return wait_rep_key
except Exception as e:
logging.info('错误为：', e)
'''获取实际替换的值'''
def get_actual_replace_key(self, row):
try:
col = get_actual_replace_key()
act_rep_key = self.opera_excel.get_cell_value(row, col)
if act_rep_key == '':
return None
return act_rep_key
except Exception as e:
logging.info('错误为：', e)
'''写入数据'''
def write_result(self, row, value):
try:
col = get_result()
self.opera_excel.write_value(sheet=self.sheet, content=value, rowNo=row, colsNo=col)
except Exception as e:
logging.info("错误为：", e)
'''获取依赖返回数据的key'''
def get_depend_key(self, row):
try:
col = get_data_depend()
depent_key = self.opera_excel.get_cell_value(row, col)
if depent_key == "":
return None
else:
return depent_key
except Exception as e:
logging.info("错误为：", e)
def is_depend(self, row): # 是否有依赖
try:
col = get_case_depend()
depend_case_id = self.opera_excel.get_cell_value(row, col)
if depend_case_id == "":
return None
else:
return depend_case_id
except Exception as e:
logging.info("错误为：", e)
'''获取数据依赖字段'''
def get_depend_field(self, row):
try:
col = get_field_depend()
data = self.opera_excel.get_cell_value(row, col)
if data == "":
return None
else:
return data
except Exception as e:
logging.info("错误为：", e)
'''获取请求方式'''
def get_set_key(self, row):
try:
col = get_set_key()
request_method = self.opera_excel.get_cell_value(row, col)
return request_method
except Exception as e:
logging.info("错误为：", e)
class GetData:
def __init__(self):
self.operation_excel = OperationExcel()
self.get_headers_cookies = GetHeadersCookies()
self.get_config = ReadConfig()
def get_sheet_names(self):
"""获取当前工作簿中所有工作表的名称"""
return self.operation_excel.get_sheet_names()
def get_sheet_data(self, sheet_name):
"""通过sheet页名称读取对应sheet页的数据"""
return self.operation_excel.get_sheet_data(sheet_name)
def get_sheet_lines(self):
"""获取当前sheet页的总行数"""
return self.operation_excel.get_sheet_lines()
def get_json_file_name(self, sheet_name):
"""获取json文件名称"""
sheet_name = "../test_data/json_data/" + sheet_name + ".json"
return sheet_name
def get_save_result_path(self):
'''获取结果文件路径'''
return self.operation_excel.save_result_path
def get_is_run(self, x):
"""获取case是否运行"""
flag = None
y = data_conf.get_run()
run_value = self.operation_excel.get_cell_value(x, y)
if run_value.lower() == 'yes':
flag = True
else:
flag = False
return flag
def get_is_header(self, x):
"""是否携带headers"""
y = data_conf.get_request_header()
header = self.operation_excel.get_cell_value(x, y)
if header == 'yes':
return self.get_headers_cookies.get_headers_value()
else:
return None
def get_is_cookie(self, x):
"""是否携带cookies"""
y = data_conf.get_request_cookie()
cookie = self.operation_excel.get_cell_value(x, y)
if cookie == 'yes':
return self.get_headers_cookies.get_cookies_value()
return None
def get_request_method(self, x):
"""获取请求方法"""
y = data_conf.get_request_method()
request_method = self.operation_excel.get_cell_value(x, y)
return request_method
def get_request_url(self, x):
"""获取请求地址"""
y = data_conf.get_url()
request_url = self.operation_excel.get_cell_value(x, y)
base_url = self.get_config.get_http_config_var('baseurl')
request_url = base_url + request_url
return request_url
def get_request_data(self, sheet_name, x):
"""获取请求数据"""
y = data_conf.get_request_data()
request_data_key = self.operation_excel.get_cell_value(x, y)
if request_data_key == '':
return None
else:
request_data = self.__get_data_for_json(sheet_name,
request_data_key)
return request_data
def __get_data_for_json(self, sheet_name, request_data_key):
"""通过excel中关键字去获取json数据"""
sheetName = self.get_json_file_name(sheet_name)
op_json = OperationJson(file_path=sheetName)
data = op_json.get_key_words(request_data_key)
return data
def get_expect_data(self, x):
"""获取预期结果数据"""
y = data_conf.get_expect_result()
expect_data = self.operation_excel.get_cell_value(x, y)
if expect_data == '':
return None
else:
return string_to_eval(x, y, expect_data)
def get_module_name(self, x):
"""获取模块名称"""
y = data_conf.get_name()
module_name = self.operation_excel.get_cell_value(x, y)
return module_name
def write_real_result(self, sheet_name, row, value):
"""写测试结果到excel"""
y = data_conf.get_real_results()
self.operation_excel.write_value(sheet_name, row, y, value)
def get_is_case_depend(self, x):
"""判断是否有case依赖"""
y = data_conf.get_case_depend()
case_depend = self.operation_excel.get_cell_value(x, y)
if case_depend == "":
return None
else:
return string_to_eval(x, y, case_depend)
def get_depend_data(self, x):
"""获取响应结果中的依赖字段"""
y = data_conf.get_data_depend()
data_depend = self.operation_excel.get_cell_value(x, y)
if data_depend == "":
return None
else:
return string_to_eval(x, y, data_depend)
def get_depend_filed(self, x):
"""获取数据依赖字段"""
y = data_conf.get_filed_depend()
filed_depend = self.operation_excel.get_cell_value(x, y)
if filed_depend == "":
return None
else:
return string_to_eval(x, y, filed_depend)
class TestRun(object):
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.common_util = CommonUtil()
self.send_email = SendEmail()
self.excel = OperationExcel()
self.sheet_obj = self.excel.get_data()
def test_run(self):
res = None
pass_count = []
fail_count = []
skip_count = []
# 获取多少行
rows_count = self.data.get_case_lines()
for i in range(2, rows_count + 1):
run_num = [2, 1]
is_run = self.data.get_is_run(i)
message = self.data.get_api_msg(i)
api_name = self.data.get_api_name(i)
if is_run:
url_path = self.data.get_request_url(i)
url = config_global.base_url[0] + url_path
method = self.data.get_request_method(i)
data = self.data.get_request_data(i)
code = self.data.get_http_code_data(i)
expect = self.data.get_expect_data(i)
headers = self.data.get_request_headers(i)
depend_Value = self.data.get_depend_value(i) # tiquzhi
set_key = self.data.get_set_key(i)
wait_key = self.data.get_waiting_replace_key(i)
actual_key = self.data.get_actual_replace_key(i)
header = get_header_value()
if data != None:
if '88888888' in data:
data = data.replace("88888888", "17154654546")
data = json.loads(data)
if headers != None:
try:
with open(depend_data_path, 'r',
encoding='utf-8') as f:
header_value = json.load(f)
header[headers] = header_value["token"]
except Exception as e:
logging.info("错误为：", e)
depend_case = self.data.is_depend(i)
if depend_case != None:
self.depend_data = DependentData(depend_case)
# 获取的依赖响应
depend_response_data = self.depend_data.get_data_for_key(i)
# 获取依赖的key
depend_key = self.data.get_depend_field(i)
# 更新参数值
data[depend_key] = depend_response_data
'''待提取的key'''
if wait_key != None:
try:
with open(depend_data_path, 'r',
encoding='utf-8') as f:
dependvalue = f.read()
depend_value_dict = json.loads(dependvalue)
wait_key_list = str_for_list(wait_key)
actual_key_list = str_for_list(actual_key)
for index_num in range(len(wait_key_list)):
Wait_key = wait_key_list[index_num]
Act_key = actual_key_list[index_num]
depend_value_key = depend_value_dict[Act_key]
data[Wait_key] = depend_value_key
except Exception as e:
logging.info("错误为：", e)
def fail_run():
response = self.run_method.run_main(
method, url, data, header)
res = response[0]
# print('response---->',response)
# print('res---->',res)
global http_code
http_code = response[1]
# print(type(http_code), http_code)
# 断言
if int(code) == http_code:
if self.common_util.is_contain(expect, res):
logging.info('\033[1;32;m%s接口:%s->接口执行通过\033[0m' %
(api_name, message))
writeTestResult(excelObj.get_data(),
rowNo=i,
testResult='pass')
pass_count.append(i)
if depend_Value != None:
self.depend_data = DependentData(depend_case)
self.depend_data.save_depend_value(
res, depend_Value, set_key)
else:
fail = run_num[0]
fail -= 1
run_num[0] = fail
while run_num[0]:
fail_num = run_num[1]
run_num[1] = run_num[1] + 1
print('第%s次执行失败，开始第%s次执行。。。' %
(fail_num, fail_num + 1))
time.sleep(1)
logging.info(
"\033[0;43;41m%s接口:%s->接口执行失败\033[0m" %
(api_name, message))
fail_run()
writeTestResult(excelObj.get_data(),
rowNo=i,
testResult='faild',
errorInfo=res)
fail_count.append(i)
else:
fail = run_num[0]
fail -= 1
run_num[0] = fail
while run_num[0]:
fail_num = run_num[1]
run_num[1] = run_num[1] + 1
print('第%s次执行失败，开始第%s次执行。。。' %
(fail_num, fail_num + 1))
time.sleep(1)
logging.info("\033[0;43;41m%s->接口执行失败\033[0m" %
message)
fail_run()
writeTestResult(excelObj.get_data(),
rowNo=i,
testResult='faild',
errorInfo=res)
fail_count.append(i)
fail_run()
else:
logging.info('%s接口:%s->接口不执行' % (api_name, message))
skip_count.append(i)
writeTestResult(excelObj.get_data(),
rowNo=i,
testResult='skip')
# 发送邮件
logging.info("正在发送邮件，请等待。。。")
from base.common_method import *
import json
import time
import requests
from utils.commonutil import CommonUtil
from data.dependent_data import DependentData
from utils.send_email import SendEmail
from utils.operation_json import OperationJson
from utils.operation_header import OPerationHeader
from utils.write_result import *
from utils.operation_excel import OperationExcel
from utils.Excel_Obj import *
from utils.Log import *
from config import config_global
obj = OperationExcel()
all_data = obj.get_excel_all_data()
@ddt.ddt
class TestAllCase(unittest.TestCase):
def setUp(self):
self.run = TestRun()
self.data = GetData()
self.run_method = RunMethod()
self.common_util = CommonUtil()
self.send_email = SendEmail()
self.excel = OperationExcel()
self.sheet_obj = self.excel.get_data()
@ddt.data(*all_data)
class TestBooks:
rqst = RequestMethod()
excel = OperationExcel('books.xlsx')
def assert_result(self, res, row):
assert res.status_code == 200
# 如果返回结果里有中文，那么就要的序列化的时候，注意参数ensure_ascii=False，否则可能断言错误
# 下面的assert xxx in xxx, in的前面和后面都是str类型
assert self.excel.get_expect(row=row) in json.dumps(
res.json(),
ensure_ascii=False) # res.text的类型是str；res.json()的类型是dict
# ###########################测试用例组织方式1：所有case都在一个函数中运行###########################
# 只根据excel中行数的不同，进行数据的循环即可
def test_books(self):
for i in range(1, self.excel.get_rows):
if self.excel.get_method(i) == 'get':
if '{bookID}' in self.excel.get_url(i):
res = self.rqst.get(url=self.excel.get_url(i).replace(
'{bookID}', read_id_from_file()))
else:
res = self.rqst.get(self.excel.get_url(i))
elif self.excel.get_method(i) == 'post':
res = self.rqst.post(url=self.excel.get_url(i),
json=self.excel.get_param(i))
write_id_to_file(res.json()[0]['datas']['id'])
elif self.excel.get_method(i) == 'put':
res = self.rqst.put(url=self.excel.get_url(i).replace(
'{bookID}', read_id_from_file()),
json=self.excel.get_param(i))
else:
res = self.rqst.delete(url=self.excel.get_url(i).replace(
'{bookID}', read_id_from_file()))
print()
print(res.json())
print()
self.assert_result(res, i)
############################测试用例组织方式2：一个case是一个函数，依次运行###########################
def test_books_001(self):
# print(self.file_obj.get_method(1), self.file_obj.get_url(1))
res = self.rqst.get(url=self.excel.get_url(1))
self.assert_result(res, row=1)
def test_books_002(self):
res = self.rqst.post(url=self.excel.get_url(row=2),
json=self.excel.get_param(row=2))
# print(res.json())
self.assert_result(res, row=2)
write_id_to_file(res.json()[0]['datas']['id'])
def test_books_003(self):
book_id = read_id_from_file()
# print(self.excel.get_url(row=3).replace('{bookID}', book_id))
res = self.rqst.get(url=self.excel.get_url(
row=3).replace('{bookID}', book_id))
# print(res.json())
self.assert_result(res, row=3)
def test_book_004(self):
# print(self.excel.get_url(row=4).replace('{bookID}', read_id_from_file()))
# print(self.excel.get_param(row=4))
res = self.rqst.put(url=self.excel.get_url(row=4).replace(
'{bookID}', read_id_from_file()),
json=self.excel.get_param(row=4))
# print(res.json())
self.assert_result(res, row=4)
def test_book_005(self):
res = self.rqst.delete(url=self.excel.get_url(
row=5).replace('{bookID}', read_id_from_file()))
# print(res.json())
self.assert_result(res, row=5)
def test_books_006(self):
res = self.rqst.get(url=self.excel.get_url(1))
print(res.json())
self.assert_result(res, row=1)
def __init__(self):
self.opera_excel = OperationExcel()
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GerData()
class TestAllCase(unittest.TestCase):
def setUp(self):
self.run = TestRun()
self.data = GetData()
self.run_method = RunMethod()
self.common_util = CommonUtil()
self.send_email = SendEmail()
self.excel = OperationExcel()
self.sheet_obj = self.excel.get_data()
@ddt.data(*all_data)
def test_all_case(self, data): # 提取值 提取值的key 待替换的key 实际替换的key
get_num, get_case_des, get_api, get_exec, get_module, get_pre, get_url, get_header, get_method, get_parames, get_hope_http_code, get_hope_response, get_results, get_run_time, get_error_msg, get_depend_Value, get_setting_key, get_wait_key, get_actual_key = data
print(get_num, get_case_des, get_api, get_exec, get_module, get_pre,
get_url, get_header, get_method, get_parames, get_hope_http_code,
get_hope_response, get_results, get_run_time, get_error_msg,
get_depend_Value, get_setting_key, get_wait_key, get_actual_key)
print("=" * 20)
print(*all_data)
# run.test_run()
res = None
pass_count = []
fail_count = []
skip_count = []
run_num = [2, 1]
is_run = get_exec # exec
message = get_case_des
api_name = get_api
if is_run == 'y':
url_path = get_url
url = config_global.base_url[0] + url_path
method = get_method
data = get_parames
code = get_hope_http_code
expect = get_hope_response
headers = get_header
depend_Value = get_depend_Value # tiquzhi
set_key = get_setting_key
wait_key = get_wait_key
actual_key = get_actual_key
header = get_header_value()
if data != None:
if '88888888' in data:
data = data.replace("88888888", "17154654546")
data = json.loads(data)
if headers != None:
try:
with open(depend_data_path, 'r', encoding='utf-8') as f:
header_value = json.load(f)
header[headers] = header_value["token"]
except Exception as e:
logging.info("错误为：", e)
# depend_case = data.is_depend(num)
depend_case = get_num
#
# if depend_case != None:
# self.depend_data = DependentData(depend_case)
# # 获取的依赖响应
# depend_response_data = self.depend_data.get_data_for_key(i)
#
# # 获取依赖的key
# depend_key = self.data.get_depend_field(i)
#
# # 更新参数值
# data[depend_key] = depend_response_data
'''待提取的key'''
if wait_key != None:
try:
with open(depend_data_path, 'r', encoding='utf-8') as f:
dependvalue = f.read()
depend_value_dict = json.loads(dependvalue)
wait_key_list = str_for_list(wait_key)
actual_key_list = str_for_list(actual_key)
for index_num in range(len(wait_key_list)):
Wait_key = wait_key_list[index_num]
Act_key = actual_key_list[index_num]
depend_value_key = depend_value_dict[Act_key]
data[Wait_key] = depend_value_key
except Exception as e:
logging.info("错误为：", e)
def fail_run():
response = self.run_method.run_main(method, url, data, header)
res = response[0]
# print('response---->',response)
# print('res---->',res)
global http_code
http_code = response[1]
# print(type(http_code), http_code)
# 断言
if int(code) == http_code:
if self.common_util.is_contain(expect, res):
logging.info('\033[1;32;m%s接口:%s->接口执行通过\033[0m' %
(api_name, message))
self.assertTrue(True) # 断言
writeTestResult(excelObj.get_data(),
rowNo=get_num,
testResult='pass')
pass_count.append(get_num)
if depend_Value != None:
self.depend_data = DependentData(depend_case)
self.depend_data.save_depend_value(
res, depend_Value, set_key)
else:
fail = run_num[0]
fail -= 1
run_num[0] = fail
while run_num[0]:
fail_num = run_num[1]
run_num[1] = run_num[1] + 1
print('第%s次执行失败，开始第%s次执行。。。' %
(fail_num, fail_num + 1))
time.sleep(1)
logging.info(
"\033[0;43;41m%s接口:%s->接口执行失败\033[0m" %
(api_name, message))
fail_run()
writeTestResult(excelObj.get_data(),
rowNo=get_num,
testResult='faild',
errorInfo=res)
self.assertTrue(False, msg=res) # 断言
fail_count.append(get_num)
else:
fail = run_num[0]
fail -= 1
run_num[0] = fail
while run_num[0]:
fail_num = run_num[1]
run_num[1] = run_num[1] + 1
print('第%s次执行失败，开始第%s次执行。。。' %
(fail_num, fail_num + 1))
time.sleep(1)
logging.info("\033[0;43;41m%s->接口执行失败\033[0m" %
message)
fail_run()
writeTestResult(excelObj.get_data(),
rowNo=get_num,
testResult='faild',
errorInfo=res)
fail_count.append(get_num)
fail_run()
else:
logging.info('%s接口:%s->接口不执行' % (api_name, message))
skip_count.append(get_num)
writeTestResult(excelObj.get_data(),
rowNo=get_num,
testResult='skip')
def __init__(self):
self.operation_excel = OperationExcel()
self.get_headers_cookies = GetHeadersCookies()
self.get_config = ReadConfig()
from utils.operation_excel import OperationExcel from config.config_global import * #创建解析Excel对象 excelObj = OperationExcel() #将Excel数据文件加载到内存 excelObj.loadWorkBook(excelpath)
def __init__(self, case_id):
self.opexcel = OperationExcel()
self.getdata = GetData()
self.case_id = case_id
self.runmethod = RunMethod()
class GerData:
def __init__(self):
self.opera_excel = OperationExcel()
#去获取excel行数，就是我们的case个数
def get_case_lines(self):
return self.opera_excel.get_lines()
#判断是否执行
def get_is_run(self,row):
flag = None
col = int(data_config.get_run())
run_model =self.opera_excel.get_cell_velue(row,col)
if run_model == 'yes':
return True
else:
return False
return flag
#判断是否携带header
def is_header(self,row):
col = int(data_config.get_header())
header = self.opera_excel.get_cell_velue(row,col)
if header == 'yes':
return data_config.get_header_value()
else:
return None
#获取请求方式
def get_request_method(self,row):
col = int(data_config.get_run_way())
request_method = self.opera_excel.get_cell_velue(row,col)
return request_method
#获取url
def get_request_url(self,row):
col = int(data_config.get_url())
url = self.opera_excel.get_cell_velue(row,col)
return url
#获取请求数据
def get_request_data(self,row):
col = int(data_config.get_data())
data = self.opera_excel.get_cell_velue(row,col)
if data == '':
return None
return data
#通过关键字拿到data数据
def get_data_for_json(self,row):
opera_json = OperetionJson()
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
#获取预期结果
def get_expect_data(self,row):
col = int(data_config.get_expect())
expect = self.opera_excel.get_cell_velue(row,col)
#print(expect)
if expect == '':
return None
return expect
#获取实际结果
def write_result(self,row,value):
col = int(data_config.get_result())
self.opera_excel.write_value(row,col,value)
#获取依赖数据的key
def get_depend_key(self,row):
col = int(data_config.get_data_depend())
depent_key = self.opera_excel.get_cell_velue(row,col)
if depent_key == '':
return None
else:
print("依赖的key:",depent_key)
return depent_key
#判断是否有case依赖
def is_depend(self,row):
col = int(data_config.get_case_depend())
depend_case_id = self.opera_excel.get_cell_velue(row,col)
if depend_case_id == "":
return None
else:
print("依赖的caseid：",depend_case_id)
return depend_case_id
#获取数据依赖字段
def get_depend_field(self,row):
col = int(data_config.get_field_depend())
depend_data = self.opera_excel.get_cell_velue(row,col)
if depend_data == "":
return None
else:
print('依赖的字段：',depend_data)
return depend_data
