class DependentData:
def __init__(self, case_id):
self.opera_excel = OperationExcel()
self.case_id = case_id
self.data = GetData()
# 通过case_id获取case_id的整行数据
def get_case_line_data(self, case_id):
rows_data = self.opera_excel.get_rows_data(case_id)
return rows_data
# 执行依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.case_id)
url = self.data.get_url(row_num)
data = self.data.get_data_for_json(row_num)
header = self.data.get_is_header(row_num)
method = self.data.get_request_method(row_num)
res = run_method.run_main(method, url, data, header)
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self, row):
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]
class RunTest:
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.com_util = CommonUtil()
def go_on_run(self):
pass_count = []
fail_count = []
rows_count = self.data.get_case_lines()
for i in range(1, rows_count):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
request_data1 = self.data.get_data_for_json(i)
request_data = json.dumps(request_data1)
expect = self.data.get_expect_data(i)
header1 = self.data.is_header(i)
header = eval(header1)
token = self.data.get_token(i)
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)
# 数据更新
request_data1[depend_key] = depend_response_data
request_data = json.dumps(request_data1)
if token == 'write':
res = self.run_method.run_main(method, url, request_data,
header)
res = json.loads(res)
op_header = OperationHeader()
op_header.write_token(res["data"])
res = json.dumps(res)
elif token == 'yes':
# 获取当前文件路径
current_path = os.path.abspath(__file__)
# 获取当前文件的父目录
father_path = os.path.dirname(current_path)
path = os.path.join(father_path, "wenjian", "cookie.json")
op_json = OperationJson(path)
token = op_json.get_data("access_token")
tokens = {'Authorization': "Bearer " + token}
# 将header与token合并
header = dict(header, **tokens)
res = self.run_method.run_main(method, url, request_data,
header)
if self.com_util.is_contain(expect, res):
self.data.write_result(i, "pass")
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
send_main(pass_count, fail_count)
class main():
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.json = UseJson()
def run(self):
res = header = method = None
pass_count = []
fail_count = []
rows_count = self.data.get_case_lines()
for i in range(1, rows_count):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
request_data = self.data.get_data_for_json(i)
# expect = self.data.get_expcet_data_for_mysql(i)
header = self.data.is_header(i)
request_name = self.data.get_request_name(i)
# depend_case = self.data.is_depend(i)
# if depend_case != None:
# self.depend_data = DependdentData(depend_case)
# #获取的依赖响应数据
# depend_response_data = self.depend_data.get_data_for_key(i)
# #获取依赖的key
# depend_key = self.data.get_depend_field(i)
#request_data[depend_key] = depend_response_data
if header == 'yes':
token = self.json.get_data("token")
head = {"token": token}
res = self.run_method.main(method)(url, request_data, head)
else:
res = self.run_method.main(method)(url, request_data)
if res['error_code'] & res['error_code'] == 0:
print("测试：" + request_name + ",", "结果：success")
#存token到文件
if 'token' in res['data']:
self.json.write_data("token", res['data']['token'])
elif res['error_code'] & res['error_code'] != 0:
print("测试：" + request_name + ",", "结果：fail" + ",",
"原因：" + res["msg"])
else:
print("测试：" + request_name + ",", "结果：fail" + ",",
"原因：" + res)
class RunTest:
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
def go_on_run(self):
rows_count = self.data.get_case_lines()
for i in range(1, rows_count):
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
is_run = self.data.get_is_run(i)
data = self.data.get_data_for_json(i)
header = self.data.is_header(i)
if is_run:
res = self.run_method.run_main(method, url, data, header)
return res
class DependData(object):
'''有依赖的case处理模块，case2依赖case1点数据
'''
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.get_data = GetData()
# 获取目标行的数据
def get_case_line_data(self):
return self.opera_excel.get_rows_data(self.case_id)
# 执行case1用例返回结果
def run_denpend(self):
run_method = RunMain()
# 执行请求
row_num = self.opera_excel.get_rows_num(self.case_id) + 1
# print(row_num)
request_json = self.get_data.get_data_json(row_num)
url = self.get_data.get_request_url(row_num)
# print(url)
request_method = self.get_data.get_request_method(row_num)
is_header = self.get_data.get_is_header(row_num)
res = run_method.run_main(url, request_method, request_json, is_header)
# 返回请求结果
return res
# 在case1用例返回的数据中，拿到case2所需要的字段的数据，返回
def get_data_key(self, row):
depend_data_key = self.get_data.get_depend_key(row)
# print(depend_data_key)
# 将str数据类型转换为json数据类型（dict字典）
response_data = json.loads(self.run_denpend())
# print(type(response_data))
# 需要在json中匹配的字段规则
jsonpath_expr = parse(depend_data_key)
# 在json数据中查找规则字段 返回一个list
male = jsonpath_expr.find(response_data)
# 返回需要的对应字段中的内容
return [match.value for match in male][0]
class DependentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel
self.data = GetData()
# 执行依赖测试获取结果
def run_dependent(self):
run_method = RunMethod()
row_num1 = self.opera_excel()
row_num = row_num1.get_rows_num(self.case_id)
request_data1 = self.data.get_data_for_json(row_num)
request_data = json.dumps(request_data1)
header1 = self.data.is_header(row_num)
header = eval(header1)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
token = self.data.get_token(row_num)
if token == 'yes':
# 获取当前文件路径
current_path = os.path.abspath(__file__)
# 获取当前文件的父目录
father_path = os.path.dirname(current_path)
path = os.path.join(father_path, "wenjian", "cookie.json")
op_json = OperationJson(path)
token = op_json.get_data("access_token")
tokens = {'Authorization': "Bearer " + token}
# 将header与token合并
header = dict(header, **tokens)
res = run_method.run_main(method, url, request_data, header)
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self, row):
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]
class RunTest:
"""docstring for RunTest"""
def __init__(self):
# 实例化http请求方法对象
self.run_method = RunMain()
# 实例化获取excel内容方法的对象
self.data = GetData()
self.com_util = CommonUtil()
# 执行程序,遍历case（除了表头）
def start_mycase(self):
pass_count = []
fail_count = []
rows_count = self.data.get_case_lines()
for i in range(2, rows_count + 1):
# 拿到是否执行的boolean
is_run = self.data.get_is_run(i)
if is_run:
# 拿到url
url = self.data.get_request_url(i)
# 拿到请求类型
request_method = self.data.get_request_method(i)
# 拿到请求需要的json参数
request_json = self.data.get_data_json(i)
# 是否需要填写header
is_header = self.data.get_is_header(i)
# 拿到预期结果
expected_data = self.data.get_expected_results(i)
# 判断用例是否需要依赖别的用例
depend_case = self.data.is_denpend(i)
if depend_case != None:
print(depend_case)
print(type(depend_case))
self.depend_data = DependData(depend_case)
#获取依赖的响应数据
# print(i)
depend_response_data = self.depend_data.get_data_key(i)
# 获取依赖的key
depend_key = self.data.get_depend_file(i)
# 更新依赖key的数据
# request_json[self.depend_data] = depend_response_data
# print("请求需要的参数:",request_json)
# print("header:",is_header)
res = self.run_method.run_main(url, request_method,
request_json, is_header)
# print(res)
# if int(res_status) == 200 :
# self.data.write_result(i,'pass')
# pass_count.append(i)
# # print('成功执行')
# else:
# self.data.write_result(i,'fail')
# fail_count.append(i)
# print('成功执行')
print(type(expected_data))
print(type(res))
if self.com_util.is_contain(expected_data, res):
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
print('成功的个数:', len(pass_count))
print('失败的个数:', len(fail_count))
