class RunTest:
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.com = CommonUtil()
#程序执行的入口
def go_on_run(self):
res = None
rows_count = int(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_way(i)
request_data = self.data.get_data_for_json(i)
expect = self.data.get_expect_data(i)
header = self.data.is_header(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
res = self.run_method.run_main(method, url, request_data,
header)
#print res
if self.com.is_contain(expect, res):
# self.data.write_result(i,'pass')
print 'pass'
else:
# self.data.write_result(i, 'fail')
print 'fail'
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 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 Dependent:
def __init__(self,case_id):
self.case_id = case_id
self.oper_excel = OperationExcel()
self.data = GetData()
self.run = RunMethod()
def dependent_run(self): #运行依赖的用例
case_row = self.oper_excel.get_case_row(self.case_id)
method = self.data.get_request_way_value(case_row)
url = self.data.get_url_value(case_row)
data = self.data.get_data_for_json(case_row)
header = self.data.get_is_header_value(case_row)
res = self.run.run_method(method,url,data,header)
return res
def dependent_key_values(self,row): #获取需要依赖键的值
response_data = self.dependent_run() #运行依赖用例，获取其返回值
requests_data = self.data.get_response_dependent_value(row) #获取返回值里的某个键的值
response_data = json.loads(response_data) #将json数据转换成python可识别的对象
json_exe = parse(requests_data) #定义一个规则，以json格式去格式化接口返回的数据
mable = json_exe.find(response_data) #按照规则来查找整个结果集
return [math.value for math in mable] #官方写法，从结果集查找某部分数据
from get_data import GetData print(GetData.get_data_for_json(1))
class RunTest:
def __init__(self):
self.getdata = GetData()
self.run_method = RunMethod()
self.oper_excel = OperationExcel()
self.common_util = CommonUtil()
self.oper_mysql = OperationMysql()
self.sen_mail = SendEmail()
def run_test(self):
id = 0
pass_count = []
fail_count = []
row = self.oper_excel.get_data_lines()
for id in range(1, row):
is_run = self.getdata.get_is_run_value(id)
if is_run:
url = self.getdata.get_url_value(id)
method = self.getdata.get_request_way_value(id)
is_header = self.getdata.get_is_header_value(id)
case_dependent = self.getdata.get_case_dependent_value(id)
response_dependent = self.getdata.get_response_dependent_value(
id)
data_dependent = self.getdata.get_data_dependent_value(id)
data = self.getdata.get_data_for_json(id)
#expect = self.getdata.get_expect_from_mysql(id)
expect = self.getdata.get_expect_value(id)
result = self.getdata.get_result_value(id)
if case_dependent != None:
self.dependent = Dependent(case_dependent)
dependent_data = self.dependent.dependent_key_values(id)
data[data_dependent] = dependent_data
#print(type(expect))
if is_header == 'write':
res = self.run_method.run_method(method, url, data)
#print(res['data']['url'])
res = json.loads(res)
#print(type(res))
oper_header = OperationHeader(res)
oper_header.write_cookie()
elif is_header == 'yes':
oper_json = OperationJson(
'D:\pycharm\python2\\testdjango\demo\detaconfig\cookie.json'
)
is_header = oper_json.get_json_data('apsid')
cookie = {'apsid': is_header}
res = self.run_method.run_method(method, url, data, cookie)
else:
res = self.run_method.run_method(method, url, data)
#print(id,res,type(res),type(expect))
#print(expect,res)
#self.sen_mail.sen_main(pass_count,fail_count)
if self.common_util.is_contain(expect, res):
self.getdata.write_data(id, 'pass')
pass_count.append(id)
print('pass')
else:
self.getdata.write_data(id, 'fail')
fail_count.append(id)
print('fail')
print(len(pass_count))
self.sen_mail.sen_main(pass_count, fail_count)
