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
def Get_Main(self, url, data=None, headers=None, cookies=None):
res = None
self.operjson = OperationJson()
if headers != None:
res = requests.post(url=url,
data=data,
headers=headers,
cookies=cookies,
verify=False)
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
else:
res = requests.post(url=url,
data=data,
cookies=cookies,
verify=False)
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
return res
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)
class OperationToken():
def __init__(self, token_path=None):
if token_path:
self.token_path = token_path
else:
self.token_path = "../data/token.json"
self.op_json = OperationJson(file_name=self.token_path)
# self.op_json = op_json.data
def write_token(self, value):
self.op_json.write_data(value)
def get_token(self):
tk = self.op_json.get_filevalue()
return tk
def get_cookie_file_data(self):
ck_file = self.op_json.get_all_value()
return ck_file
def trans_response_token_value_by_body(self, response):
tk_value = response.json()["data"]["token"]
print('获取到token value:', tk_value)
return tk_value
def trans_respons_token_value_by_headers(self, response):
try:
tk_value = response.headers["token"] #需要修改为自己项目的token header
return tk_value
except:
print("通过headers获取token,失败", str(response))
return ""
class OperationCookie():
def __init__(self, cookie_path=None):
if cookie_path:
self.cookie_path = cookie_path
else:
self.cookie_path = "../data/cookie.json"
self.op_json = OperationJson(file_name=self.cookie_path)
# self.op_json = op_json.data
def write_cookie(self, value):
self.op_json.write_data(value)
def get_cookie(self, key):
ck = self.op_json.get_value(key)
return ck
def get_cookie_file_data(self):
ck_file = self.op_json.get_all_value()
return ck_file
def trans_response_cookie_value(self, response):
# print(response.cookies,response.content)
ck_value = requests.utils.dict_from_cookiejar(response.cookies)
print('cookie value:', ck_value)
return ck_value
def __init__(self):
self.session = requests.session()
self.operation_json = OperationJson("../test_data/json_data/user.json")
self.url = self.operation_json.get_key_words("login_url")
self.data = self.operation_json.get_key_words("login_data")
self.header = self.operation_json.get_key_words("header")
self.cookie = {}
self.context = {}
class GetHeadersCookies:
def __init__(self):
self.op_json = OperationJson()
def get_headers_value(self):
return self.op_json.get_key_words("header")
def get_cookies_value(self):
return self.op_json.get_key_words("cookie")
def __init__(self):
read_conf = ReadConfig() # 邮件发送开关
self.is_on = read_conf.get_email_config_var('on_off')
self.run_method = RunMethod()
self.data = GetData()
self.public_util = PublicUtil()
self.headers_and_cookies = OperationJson()
self.cookies = self.headers_and_cookies.get_key_words("cookie")
self.headers = self.headers_and_cookies.get_key_words("header")
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_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
def go_on_run(self):
pass_count = []
fail_count = []
cookies = None
rows = self.getdata.get_case_lines()
for i in range(1, rows):
is_run = self.getdata.get_is_run(i)
if is_run:
url = self.getdata.get_url(i)
is_depend = self.getdata.is_depend(i)
request_method = self.getdata.get_request_method(i)
expect = self.getdata.get_expect(i)
# print(expect)
is_cookie = self.getdata.is_cookie(i)
is_header = self.getdata.is_header(i)
data = self.getdata.get_data_for_json(i)
print(data)
depend_case = self.getdata.is_depend(i)
if is_depend:
self.depend_data = DependentData(depend_case)
field_depend = self.getdata.get_field_depend(i)
data_depend = self.depend_data.get_data_for_key(i)
data[field_depend] = data_depend
if is_cookie == 'write':
res = self.runmethod.run_main(url, request_method, data)
op_cookie = OperationCookie(json.loads(res))
op_cookie.write_cookie()
if is_cookie == 'yes':
op_json = OperationJson('../dataconfig/cookie.json')
cookie = op_json.get_data("apsid")
cookies = {"apsid": cookie}
res = self.runmethod.run_main(url, request_method, data,
is_header, cookies)
if self.commonutil.iscontain(expect, res):
print("测试通过")
self.getdata.write_result(i, "测试通过")
pass_count.append(i)
else:
print(expect)
print(res)
print("测试失败")
self.getdata.write_result(i, res)
fail_count.append(i)
else:
return None
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"]
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
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, token_path=None):
if token_path:
self.token_path = token_path
else:
self.token_path = "../data/token.json"
self.op_json = OperationJson(file_name=self.token_path)
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
class RunTest(object):
def __init__(self):
read_conf = ReadConfig() # 邮件发送开关
self.is_on = read_conf.get_email_config_var('on_off')
self.run_method = RunMethod()
self.data = GetData()
self.public_util = PublicUtil()
self.headers_and_cookies = OperationJson()
self.cookies = self.headers_and_cookies.get_key_words("cookie")
self.headers = self.headers_and_cookies.get_key_words("header")
def request_depend_logic(self, request_data, depend_case, depend_data,
depend_filed, sheet, row_count):
if depend_case == False:
error = "工作表{0}中的第{1}行的case_id字段的数据类型错误". \
format(sheet, row_count + 1)
log.error(error)
return
if not isinstance(depend_case, list):
error = "工作表{0}中的第{1}行的case_id字段值外层数据不是列表类型的数据" \
.format(sheet, row_count + 1)
log.error(error)
return
if depend_data is None or depend_data == False:
error = "工作表{0}中的第{1}行的depend_data字段值不可为空或者数据类型错误". \
format(sheet, row_count + 1)
log.error(error)
return
if not isinstance(depend_data, list):
error = "工作表{0}中的第{1}行填写的depend_data字段值外层数据不是列表类型的数据". \
format(sheet, row_count + 1)
log.error(error)
return
if depend_filed is None or depend_filed == False:
error = "工作表{0}中的第{1}行的depend_filed字段值不可为空或者数据类型错误！". \
format(sheet, row_count + 1)
log.error(error)
return
if not isinstance(depend_filed, list):
error = "工作表{0}中的第{1}行的depend_filed字段值外层数据不是列表类型的数据". \
format(sheet, row_count + 1)
log.error(error)
return
if not (len(depend_case) == len(depend_data) == len(depend_filed)):
error = "工作表{0}中的第{1}行填写的depend_case,depend_data,depend_filed三个外层列表的长度不相等" \
.format(sheet, row_count + 1)
log.error(error)
return error
for case_depend, data_depend, filed_depend in zip(
depend_case, depend_data, depend_filed):
if not isinstance(case_depend, list):
error = "工作表{0}中的第{1}行的case_id字段值内层数据“{2}”不是列表类型的数据" \
.format(sheet, row_count + 1, case_depend)
log.error(error)
return
if len(case_depend) != 2:
error = "工作表{0}中的第{1}行的case_id字段值内层数据列表“{2}”的长度不等于2" \
.format(sheet, row_count + 1, case_depend)
log.error(error)
return
if not isinstance(data_depend, list):
error = "工作表{0}中的第{1}行的data_depend字段值内层数据“{2}”不是列表类型的数据" \
.format(sheet, row_count + 1, data_depend)
log.error(error)
return
if not isinstance(filed_depend, list):
error = "工作表{0}中的第{1}行的filed_depend字段值内层数据“{2}”不是列表类型的数据" \
.format(sheet, row_count + 1, filed_depend)
log.error(error)
return
if len(data_depend) != len(filed_depend):
error = "工作表{0}中的第{1}行的depend_data和depend_filed字段的内层列表数据{2}和{3}的长度不相等" \
.format(sheet, row_count + 1, data_depend, filed_depend)
log.error(error)
return
depend_data = DependentData(request_data, case_depend, data_depend,
filed_depend)
request_data = depend_data.get_data_for_key()
return request_data
def run_case_logic(self):
res = None
pass_list = []
fail_list = []
result_path = self.data.get_save_result_path() # 获取结果文件路径
sheetName = self.data.get_sheet_names() # 获取当前工作簿中所有工作表的名称
for sheet in sheetName:
self.data.get_sheet_data(sheet) # 通过sheet页名称读取对应sheet页的数据
row_counts = self.data.get_sheet_lines() # 获取sheet页的总行数
for row_count in range(1, row_counts):
log.info("工作表：{0}-->行号：{1} {2}".format(sheet, row_count,
"=" * 200))
is_run = self.data.get_is_run(row_count)
if is_run:
url = self.data.get_request_url(row_count)
log.info("请求地址： {}".format(url))
method = self.data.get_request_method(row_count)
log.info("请求方法： {}".format(method))
request_data = self.data.get_request_data(sheet, row_count)
log.info("请求数据： {}".format(request_data))
header = self.data.get_is_header(row_count)
log.info("请求头部： {}".format(header))
cookies = self.data.get_is_cookie(row_count)
log.info("Cookies： {}".format(cookies))
expect_list = self.data.get_expect_data(row_count)
log.info("预期结果： {}".format(expect_list))
depend_case = self.data.get_is_case_depend(row_count)
if depend_case is not None: # 处理依赖关系
log.info("开始处理接口之间的依赖关系流程{}".format(">" * 150))
log.info("依赖case： {}".format(depend_case))
depend_data = self.data.get_depend_data(row_count)
log.info("依赖数据： {}".format(depend_data))
depend_filed = self.data.get_depend_filed(row_count)
log.info("依赖字段： {}".format(depend_filed))
request_data = self.request_depend_logic(
request_data, depend_case, depend_data,
depend_filed, sheet, row_count)
log.info("更新请求数据:{}".format(request_data))
log.info("结束处理接口之间的依赖关系流程{}".format("<" * 150))
res = self.run_method.run_method(method, url, request_data,
header, cookies)
if self.public_util.is_contain(expect_list, res):
self.data.write_real_result(sheet, row_count, 'pass')
pass_list.append([sheet, row_count])
else:
log.info("结果比对fail的响应{}".format(res))
self.data.write_real_result(sheet, row_count, res)
fail_list.append([sheet, row_count])
return pass_list, fail_list, result_path
def run(self):
# 运行所有case
result = list(self.run_case_logic())
# 发送邮件
if self.is_on == 'on':
sendEmail = SendEmail()
sendEmail.send_email(result[0], result[1], result[2])
log.info("本次测试完成，已将测试结果通过邮件发送至各位，请注意查收！")
else:
log.info("邮件发送开关配置关闭，请打开开关后可正常自动发送测试报告")
def write_cookie(self):
op_json = OperationJson("../dataconfig/cookie.json")
op_json.write_json(self.get_cookie())
def __init__(self):
self.op_json = OperationJson()
class GetAuthorization:
def __init__(self):
self.session = requests.session()
self.operation_json = OperationJson("../test_data/json_data/user.json")
self.url = self.operation_json.get_key_words("login_url")
self.data = self.operation_json.get_key_words("login_data")
self.header = self.operation_json.get_key_words("header")
self.cookie = {}
self.context = {}
def do_login(self):
"""登录操作"""
res = self.session.post(url=self.url, data=self.data)
status_code = res.status_code
if status_code == 200:
return res.json()
else:
return "登录失败"
def api_authorize(self,data):
res = requests.get(url=data)
request_headers = res.request.headers
cookie_jar = res.cookies
response_cookie = utils.dict_from_cookiejar(cookie_jar)
request_cookie = request_headers['Cookie']
return request_cookie,response_cookie
def data_transducer(self,string: str) -> dict:
"""
:param string: token=eyJ0eXAiOiJK; auth_id=bd43fe2426081aa5a8b0a2773d006f70; auth_sys=d41d8cd98f00b204e9800998ecf8427e
:return: {'token': 'eyJ0eXAiOiJK', 'auth_id': 'bd43fe2426081aa5a8b0a2773d006f70', 'auth_sys': 'd41d8cd98f00b204e9800998ecf8427e'}
"""
dic = {}
for s in string.split("; "):
d = s.split("=")
dic[d[0]] = d[1]
return dic
def get_authorization(self):
do_login_res = self.do_login()
link_url = do_login_res['info']
api_authorize = list(self.api_authorize(link_url))
request_cookie = self.data_transducer(api_authorize[0])
response_cookie = api_authorize[1]
self.cookie.update(response_cookie)
self.cookie.update(request_cookie)
token = self.cookie['token']
self.cookie.pop("token")
X_XSRF_TOKEN = response_cookie['XSRF-TOKEN']
Authorization = "Bearer " + token
self.header['X-XSRF-TOKEN'] = X_XSRF_TOKEN
self.header['Authorization'] = Authorization
self.context['cookie'] = self.cookie
self.context['header'] = self.header
content = json.dumps(self.context,ensure_ascii=False,indent=2,sort_keys=True)
file_path = "../test_data/json_data/header_cookie.json"
self.operation_json.write_data(file_path,content)
class RunQuest:
def __init__(self, url, method, data, headers, cookies=None):
self.res = self.Run_Main(url, method, data, headers, cookies)
def Post_Main(self, url, data=None, headers=None, cookies=None):
res = None
self.operjson = OperationJson()
if headers != None:
res = requests.post(url=url,
data=data,
headers=headers,
cookies=cookies,
verify=False) #,verify=False 忽略https
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
# if res.status_code != 200:
# res=str(res.status_code)+";"+res.text
# else:
# res=res.json()
else:
res = requests.post(url=url,
data=data,
cookies=cookies,
verify=False)
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
return res
def Get_Main(self, url, data=None, headers=None, cookies=None):
res = None
self.operjson = OperationJson()
if headers != None:
res = requests.post(url=url,
data=data,
headers=headers,
cookies=cookies,
verify=False)
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
else:
res = requests.post(url=url,
data=data,
cookies=cookies,
verify=False)
print(res.status_code)
if self.operjson.is_json(res.text):
res = res.json()
else:
res = str(res.status_code) + ";" + res.text
return res
def Run_Main(self, url, method, data, headers, cookies):
res = None
if method == "POST":
res = self.Post_Main(url, data, headers, cookies)
else:
res = self.Get_Main(url, data, headers, cookies)
return res
def __init__(self, cookie_path=None):
if cookie_path:
self.cookie_path = cookie_path
else:
self.cookie_path = "../data/cookie.json"
self.op_json = OperationJson(file_name=self.cookie_path)
