def go_on_run(self):
res = None
pass_conut = []
fail_conut = []
rows_conut = self.data.get_case_lines()
for i in range(1, rows_conut):
is_run = self.data.get_is_run(i)
if is_run:
self.request_type = self.data.get_request_type(i)
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
request_data = self.data.get_json_data(i)
case_name = self.data.get_case_name(i)
cookie = self.data.get_cookies_value(i)
expect = self.data.get_expect_data(i)
depent_case = self.data.case_id(i) # 获取依赖字段的key
if depent_case is not None:
# 获取依赖的key
depent_key = self.data.get_depnet_file(i)
self.depend_data = DepnedentData(depent_case)
# 获取依赖的响应数据
depnet_response_data = self.depend_data.get_data_for_key(i)
le = len(depent_key.split(">")) # 切分字符串取大小
for y in range(0, le):
re = depent_key.split(">")
request_data[re[y]] = depnet_response_data[y] # 循环替换
if cookie == 'write':
# 发送请求
res = self.run_method.run_main(method, url, request_data)
op_cookies = OperationHeader(res)
op_cookies.write_cookie() # 写入cookies到cookie.json文件中
elif cookie == 'yes':
get_cookie = OperationJson('../dataconfig/cookie.json')
cooki = get_cookie.get_data('SESSION')
cookies = {
"SESSION": cooki
}
res = self.run_method.run_main(method, url, request_data, cookies)
else:
res = self.run_method.run_main(method, url, request_data)
if self.containt.is_contain(expect, res):
self.data.write_result(i, 'pass')
pass_conut.append(i)
self.logger.info("测试通过")
self.logger.info("通过响应数据" + res)
print("测试通过")
else:
self.logger.info("测试失败")
self.logger.info("失败case名称：" + case_name)
self.logger.info("失败的行数：" + str(i))
self.data.write_result(i, res)
fail_conut.append(i)
print("测试失败")
self.logger.info("url:" + url)
self.logger.info("失败请求数据:" + str(request_data))
self.logger.info("失败响应数据:" + res)
# 发送测试报告邮件
self.email.send_main(pass_conut, fail_conut)
class RunTest(object):
def __init__(self):
self.common_util = CommonUtil()
self.send_email = SendEmail()
self.connect_db = OperationMySQL()
self.run_method = RunMethod()
self.op_json = OperationJson()
def run(self):
res = None
pass_count = []
fail_count = []
rows_count = self.connect_db.get_count()
print(rows_count)
for i in range(0, rows_count):
run = self.connect_db.search('run', i)
if run:
url = self.connect_db.search('url', i)
request_method = self.connect_db.search('request_method', i)
request_data = self.op_json.get_data(
self.connect_db.search('request_data', i))
expect = self.connect_db.search('expect', i)
print(expect)
res = self.run_method.run_main(request_method, url,
request_data)
print(res)
if self.common_util.is_contain(expect, res) == 1:
self.connect_db.write('pass', i + 1)
pass_count.append(i + 1)
print(pass_count)
else:
self.connect_db.write(res, i + 1)
fail_count.append(i + 1)
print(fail_count)
self.send_email.send_main(pass_count, fail_count)
def get_data_for_json(self, row):
# 不在构造函数，而在这里实例化，因为有的data不需要json
opera_json = OperationJson()
# 数据来源-excel，可直接调用
# request_data = opera_json.get_data(self.get_request_data())
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
def getdata(self, row, json_data_name=None):
opera_json = OperationJson(json_data_name)
request_key = self.get_request_data(row)
request_data = opera_json.get_data(request_key)
if request_data == '':
return None
else:
return request_data
def get_data_for_json(self, row):
"""
通过json获取关键字对应的数据
:param row: 所在行数
:return: 关键字对应的数据
"""
operation_json = OperationJson()
return operation_json.get_data(self.get_request_data(row))
def get_request_for_json(self, rowx):
oper_json = OperationJson()
request_key = self.get_request_key(rowx)
if request_key is None:
request_data = None
else:
request_data = oper_json.get_data(request_key)
return request_data
def get_data_for_json(self, row):
opera_json = OperationJson()
test = json.dumps(self.get_request_data(5))
print(test, '111')
# request_data = opera_json.get_data(json.dumps(self.get_request_data(row)))
request_data = opera_json.get_data(
json.dumps(self.get_request_data(row)))
return request_data
def go_on_run(self):
# 10 0,1,2,3,
res = None
pass_count = []
fail_count = []
rows_count = self.data.get_case_lines()
print(rows_count)
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)
print(i, url)
method = self.data.get_request_method(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)
# res = self.run_method.run_main(method, url, data, header)
# if is_run:
# method,url,data=None,header=None
if depend_case != None:
# self.depend_data = DependentData(depend_case)
print("depend_case is" + " --- " + depend_case)
self.depend_data = DependentData(depend_case)
# 获取的依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(i)
# 获取依赖的key
print(depend_response_data)
depend_key = self.data.get_depend_field(i)
print(depend_key)
request_data[depend_key] = depend_response_data
if header == "write":
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperationJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
# cookie = op_header.get_data()
# cookie = ../dataconfig/cookie.json ../dataconfig/cookie.json
res = self.run_method.run_main(method, url, request_data,
cookies)
else:
res = self.run_method.run_main(method, url, request_data)
# res = self.run_method.run_main(method,url,request_data,header)
# print(res)
if self.com_util.is_contain(expect, res):
# print("测试通过")
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
# print("测试失败")
# self.data.write_result(i, 'fail')
self.data.write_result(i, res)
fail_count.append(i)
self.send_email.send_main(pass_count, fail_count)
def get_data_for_json(self, row):
"""
通过关键字拿到data数据
:param row:
:return:
"""
opera_json = OperationJson()
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
def go_on_run(self):
"""程序执行"""
pass_count = []
fail_count = []
res = None
# 获取用例数
rows_count = self.data.get_case_lines()
# 第一行索引为0
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(i)
header = self.data.is_header(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_data[depend_key] = depend_response_data
# 如果header字段值为write则将该接口的返回的token写入到token.json文件，如果为yes则读取token.json文件
if header == "write":
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_token()
elif header == 'yes':
op_json = OperationJson("../dataconfig/token.json")
token = op_json.get_data('data')
request_data = dict(request_data,
**token) # 把请求数据与登录token合并，并作为请求数据
res = self.run_method.run_main(method, url, request_data)
else:
res = self.run_method.run_main(method, url, request_data)
if expect != None:
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)
else:
print("用例ID：case-{i}，预期结果不能为空")
# 发送邮件
# self.send_email.send_main(pass_count, fail_count)
print("通过用例数：{len(pass_count)}")
print("失败用例数：{len(fail_count)}")
def get_data_for_json(self, row):
"""
通过关键字拿到data数据
:param row:
:return:
"""
print("1111111111111", row)
opera_json = OperationJson()
print("22222222222222222")
print(self.get_request_data(row))
request_data = opera_json.get_data(self.get_request_data(row))
print("request_data:", request_data)
return request_data
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)
data = self.data.get_data_for_json(i)
# expect = self.data.get_expect_data(i) # Excel写入预期结果
expect = self.data.get_expect_data_for_mysql(i)
header = self.data.is_header(i)
depend_case = self.data.is_depend(i)
res = self.run_method.run_main(method, url, data, header)
values = {"resultCode": res["resultCode"]}
# print(res["resultData"]["access_id"])
value = json.dumps(values) # 字典转字符串匹配
if depend_case is not None:
self.depend_data = DependentDate(depend_case)
# 依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(i)
# 获取依赖的key
data = json.loads(data)
depend_key = self.data.get_depend_field(i)
data[depend_key] = depend_response_data
if header == 'write':
res = self.run_method.run_main(method, url, data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperationJson('../dataconfig/cooking.json')
cookie = op_json.get_data('apsid')
cookies = {
'apsid': cookie
}
value = self.run_method.run_main(method, url, data, cookies)
else:
value = self.run_method.run_main(method, url, data)
if self.commonutil.is_equal_dict(expect, value):
self.data.write_result(i, '通过')
pass_count.append(i)
print('测试通过')
else:
self.data.write_result(i, '失败')
fail_count.append(i)
print('测试失败')
print(pass_count, fail_count)
self.sendmail.send_main(pass_count, fail_count)
def go_on_run(self):
"""
执行测试用例
:return: 通过用例和失败用例
"""
pass_list = []
fail_list = []
rows_count = self.data.get_case_num()
for i in range(1, rows_count):
is_run = self.data.is_run(i)
if is_run:
url = self.data.get_request_url(i)
method = self.data.get_method(i)
data = self.data.get_data_for_json(i)
cookie = self.data.is_cookie(i)
header = self.data.is_header(i)
expect = self.data.get_expect_data(i)
if isinstance(expect, float):
expect = str(int(expect))
depend_case = self.data.is_depend(i)
if depend_case is not None:
depend_data = DependentData(depend_case)
# 获取依赖响应的返回数据
depend_response_data = depend_data.get_data_for_key(i)
# # 使用mock-test模拟请求
# depend_response_data = mock_test(self.run_method.run_main, data, url, "POST", order)
# 获取依赖的字段
depend_field = self.data.get_depend_field(i)
# 更新
data[depend_field] = depend_response_data
if cookie == 'write':
res = self.run_method.run_main(method, url, data, header)
opera_cookie = OperationCookie(res)
opera_cookie.write_cookie()
elif cookie == 'yes':
op_json = OperationJson('../data_config/cookie.json')
cookie = op_json.get_data('ASP.NET_SessionId')
cookies = {'ASP.NET_SessionId': cookie}
res = self.run_method.run_main(method, url, data, cookies)
else:
res = self.run_method.run_main(method, url, data)
if self.common_util.is_contain(expect, res.text):
# print("PASS")
pass_list.append(i)
self.data.write_result(i, 'PASS')
else:
# print("FAILED")
fail_list.append(i)
self.data.write_result(i, 'FAILED')
self.send_email.send_main(pass_list, fail_list)
def go_on_run(self, request_value, reponse_value):
lines = self.data.get_case_lines()
pass_count = []
fail_count = []
for i in range(1, lines):
is_run = self.data.get_is_run(i)
if is_run:
res = None
url = self.data.get_url(i)
method = self.data.get_method_type(i)
# request_data = self.data.get_request_for_json(i)
# expected = self.data.get_expected_result(i)
fix_request_key = self.data.get_fix_request_key(i)
if fix_request_key is not None:
request_data = self.run_request_data(i, request_value)
expected = self.run_expected_data(i, reponse_value)
else:
request_data = self.data.get_request_for_json(i)
expected = self.data.get_expected_result(i)
header = self.data.get_header(i)
is_depend = self.data.is_depend(i)
if is_depend is not None:
depend_case_id = self.data.get_depend_case_id(i)
depend_request = self.data.get_depend_request(i)
depend_data = DependData(depend_case_id)
depend_response = depend_data.get_data_for_key(
i) # 从依赖接口的返回结果中匹配需要的依赖字段
request_data[depend_request] = depend_response
# if header == 'write':
# res = self.run.run_main(url, method, request_data)
# oper_header = OperationHeader()
# oper_header.write_cookie()
if header == 'yes':
op_json = OperationJson('../dataconfig/esage_cookies.json')
cookie = op_json.get_data('Cookie')
cookies = {'Cookie': cookie}
res = self.run.run_main(url, method, request_data, cookies)
else:
res = self.run.run_main(url, method, request_data)
if self.comm.contrast(expected, res):
print("测试通过")
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
print("测试失败")
self.data.write_result(i, res)
fail_count.append(i)
def run_depnedent(self):
run_method = RunMethod()
row_num = self.operation.get_rows_num(self.case_id) # 获取行号
request_data = self.data.get_json_data(row_num) # 获取请求数据
method = self.data.get_request_method(row_num) # 获取请求方法
url = self.data.get_request_url(row_num)
cookies = {"SESSION": "bdbd5d09-29c5-40f8-aa16-cae274c1c6cd"}
cookie = self.data.get_cookies_value(row_num)
if cookie == 'yes':
get_cookie = OperationJson('../dataconfig/cookie.json')
cooki = get_cookie.get_data('SESSION')
cookies = {"SESSION": cooki}
res = run_method.run_main(method, url, request_data,
cookies) # 发送请求
else:
res = run_method.run_main(method, url, request_data)
return json.loads(res)
def run_depend_case(self):
run_method = RunMethod()
row_num = self.operation.get_row_num(self.casi_id) # 获取行号
request_data = self.data.get_json_data(row_num) # 获取请求数据
request_method = self.data.get_request_way(row_num) # 获取请求方法
url = self.data.get_url(row_num)
cookie = self.data.get_is_cookies(row_num)
if cookie == 'yes':
operation = OperationJson('../data/scm-cookies.json')
cookie = operation.get_data('SESSION')
cookies = {
"SESSION": cookie
}
res = run_method.run_main(request_method, url, request_data, cookie)
else:
res = run_method.run_main(request_method, url, request_data)
return json.loads(res)
def get_data_for_key(self, row):
"""
获取响应数据中的依赖返回值
:param row: 行数
:return: 依赖返回值
"""
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
if "validateCookie" in depend_data:
cookie = OperationCookie(response_data)
cookie.write_cookie()
code = OperationJson('../data_config/cookie.json')
return code.get_data(depend_data)[8:]
else:
json_rules = parse(depend_data)
result = json_rules.find(json.loads(response_data.text))
return [math.value for math in result][0]
def run(self):
res = None
pass_count = []
fail_count = []
rows_count = self.data.get_case_lines()
for i in range(1, rows_count):
run = self.data.get_run(i)
if run:
url = self.data.get_url(i)
request_method = self.data.get_request_method(i)
request_data = self.data.get_data_for_json(i)
expect = self.data.get_expect(i)
print(expect)
header = self.data.get_header(i)
# case_depend = self.data.get_case_depend(i)
# if case_depend != None:
# self.depend_data = DependentData(case_depend)
# depend_response_data = self.depend_data.get_data_for_key(i)
# depend_key = self.data.get_depend_response_data(i)
# request_data[depend_key] = depend_response_data
if header == 'write':
res = self.run_method.run_main(request_method, url,
request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperationJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
res = self.run_method.run_main(request_method, url,
request_data, cookies)
else:
res = self.run_method.run_main(request_method, url,
request_data)
print(res)
if self.common_util.is_contain(expect, res) == 1:
self.data.write_result(i, 'pass')
pass_count.append(i)
print(pass_count)
else:
self.data.write_result(i, res)
fail_count.append(i)
print(fail_count)
self.send_email.send_main(pass_count, fail_count)
def go_no_run(self, i):
rows_conut = self.data.get_case_lines() # 获取行数
is_run = self.data.get_is_run(i)
print(is_run)
if is_run:
url = self.data.get_url(i)
method = self.data.get_request_way(i) # 获取请求的方法
request_data = self.data.get_json_data(i) # 获取请求数据
data_type = self.data.get_data_type(i)
print(data_type)
cookie = self.data.get_is_cookies(i) # 获取cookies
expect = self.data.get_expect(i) # 获取预期结果
result = self.data.get_result(i)
depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid
if depend_case is not None:
# 获取替换请求字段
depend_key = self.data.get_depned_key(i)
# 获取依赖的响应数据
self.depend_data = DependData(depend_case)
depend_response_data = self.depend_data.get_depned_value(i)
split = len(depend_key.split(">")) # 切割替换的字段
# 根据请求字段的个数替换
for y in range(0, split):
re = depend_key.split(">")
request_data[re[y]] = depend_response_data[y]
if cookie == 'write':
res = self.run_method.run_main(method, url, request_data)
op_cookie = OperationCookie(res) # 获取cookies
op_cookie.write_cookie() # 写入cookies
elif cookie == 'yes':
get_cookies = OperationJson('../data/scm-cookies.json')
cooki = get_cookies.get_data('SESSION')
cookies = {"SESSION": cooki}
res = self.run_method.run_main(method, url, request_data,
cookies, data_type)
else:
res = self.run_method.run_main(method, url, request_data)
if self.is_contain.is_contain(expect, res):
self.data.write_data(i, 'pass')
print(res)
else:
self.data.write_data(i, 'fail')
print(res)
class GetData(object):
"""这是GetData"""
def __init__(self):
self.op_excel = OperationExcel()
self.op_json = OperationJson()
def get_case_lines(self):
return self.op_excel.get_line_length()
def get_request_url(self, row):
col = global_var.get_col_url()
return self.op_excel.get_cell_value(row, col)
def get_request_method(self, row):
col = global_var.get_col_method()
return self.op_excel.get_cell_value(row, col)
def get_request_data(self, row):
col = global_var.get_col_data()
return self.op_excel.get_cell_value(row, col)
def get_is_run(self, row):
col = global_var.get_col_run()
return self.op_excel.get_cell_value(row, col)
# 根据关键字获取请求数据json
def get_request_data_by_json(self, row):
key = self.get_request_data(row)
return self.op_json.get_data(key)
def get_header(self, row):
col = global_var.get_col_header()
return self.op_excel.get_cell_value(row, col)
def get_expect_result(self, row):
col = global_var.get_col_expect()
return self.op_excel.get_cell_value(row, col)
def write_actual_result(self, row, result):
col = global_var.get_col_actual()
return self.op_excel.write_cell_value(row, col, result)
class GetData:
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_value(row, col)
if run_model == 'yes':
flag = True
else:
flag = False
return flag
#是否携带header
def get_is_header(self, row):
col = int(data_config.get_header())
header = self.opera_excel.get_cell_value(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_value(row, col)
return request_method
#获取url
def get_request_url(self, row):
col = int(data_config.get_url())
url = self.opera_excel.get_cell_value(row, col)
return url
#获取请求数据
def get_request_data(self, row):
col = int(data_config.get_data())
data = self.opera_excel.get_cell_value(row, col)
if data == '':
return None
else:
return data
#通过获取关键字拿到data数据
def get_data_for_json(self, row):
self.opera_json = OperationJson()
request_data = self.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_value(row, col)
if expect == '':
return None
return expect
#通过sql获取预期结果
def get_expect_data_for_sql(self, row):
op_mysql = OperationSql()
sql = self.get_expect_data(row)
res = op_mysql.search_one(sql)
return res
#将运行结果写入excel
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())
depend_key = self.opera_excel.get_cell_value(row, col)
if depend_key == '':
return None
else:
return depend_key
#判断是否有case依赖
def is_depend(self, row):
col = int(data_config.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
#获取数据依赖字段
def get_depend_field(self, row):
col = int(data_config.get_field_depend())
data = self.opera_excel.get_cell_value(row, col)
if data == '':
return None
else:
return data
def go_no_run(self):
rows_conut = self.data.get_case_lines() # 获取行数
for i in range(1, rows_conut):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_url(i)
case_name = self.data.get_case_name(i)
method = self.data.get_request_way(i) # 获取请求的方法
request_data = self.data.get_json_data(i) # 获取请求数据
data_type = self.data.get_data_type(i)
cookie = self.data.get_is_cookies(i) # 获取cookies
expect = self.data.get_expect(i) # 获取预期结果
depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid
if depend_case is not None:
# 获取替换请求字段
depend_key = self.data.get_depned_key(i)
# 获取依赖的响应数据
self.depend_data = DependData(depend_case)
depend_response_data = self.depend_data.get_depned_value(i)
split = len(depend_key.split(">")) # 切割替换的字段
# 根据请求字段的个数替换
for y in range(0, split):
re = depend_key.split(">")
request_data[re[y]] = depend_response_data[y]
if cookie == 'write':
res = self.run_method.run_main(method, url, request_data)
op_cookie = WriteCookies(res) # 获取cookies
op_cookie.write_cookie() # 写入cook ies
elif cookie == 'yes':
get_cookies = OperationJson('../data/scm-cookies.json')
coo = get_cookies.get_data('SESSION')
cooki = {"SESSION": coo}
res = self.run_method.run_main(method, url, request_data,
cooki, data_type)
else:
# get_cookies = OperationJson('../data/scm-cookies.json')
# cooki = get_cookies.get_data('accessToken')
# request_data['accessToken'] = cooki
res = self.run_method.run_main(method, url, request_data)
if self.is_contain.is_contain(expect, res):
self.data.write_data(i, 'pass')
self.logger.info("第" + str(i) + "个case-->" + case_name +
": 测试通过")
self.logger.info("url--> " + url)
self.logger.info("request_data-->" + str(request_data))
self.logger.info("response_data-->" + res)
print("第" + str(i) + "个case-->" + case_name + ": 测试通过")
print(res)
else:
self.data.write_data(i, res)
self.logger.info("第" + str(i) + "个case-->" + case_name +
": 测试失败")
self.logger.info("url--> " + url)
self.logger.info("request_data-->" + str(request_data))
self.logger.info("response_data-->" + res)
print("第" + str(i) + "个case-->" + "测试失败")
print(res)
class GetData: def __init__(self): self.opera_excel = OperationExcel() self.opera_json = OperationJson() self.opera_header = op_header_json() self.data_config = data.data_config #self.data_config = self.data.data_config def get_case_lines(self): return self.opera_excel.get_lines() #获取是否执行 def get_is_run(self,row): flag = None col = int(self.data_config.get_run()) run_model = self.opera_excel.get_cell_value(row,col) if run_model == 'yes': flag = True else: flag = False return flag #是否有header def is_header(self,row): col = int(self.data_config.get_header()) header = self.opera_excel.get_cell_value(row,col) return header #根据获取到header值，获取json数据 def get_header_json(self,row): header = self.is_header(row) if header != None: return self.opera_header.get_header_value(header) else: return None #获取请求方式 def get_request_methon(self,row): col = int(self.data_config.get_run_way()) request_method = self.opera_excel.get_cell_value(row,col) return request_method #获取url def get_url(self,row): col = int(self.data_config.get_url()) url = self.opera_excel.get_cell_value(row,col) return url #获取请求数据 def get_request_data(self,row): col = int(self.data_config.get_data()) data = self.opera_excel.get_cell_value(row,col) if data != '': return data else: return None #通过关键字获取data数据 def get_data_for_json(self,row): request_data = self.get_request_data(row) if request_data != None: data = self.opera_json.get_data(request_data) else: return None return data #获取预期结果 def get_except_data(self,row): col = int(self.data_config.get_expect()) request_data = self.opera_excel.get_cell_value(row,col) if request_data !='': return request_data else: return None def write_result(self,row,value): col = int(self.data_config.get_result()) self.opera_excel.write_value(row,col,value) # if __name__ == '__main__': # getdata=GetData() # print(getdata.get_header_json(1)) # print(getdata.get_except_data(1))
def go_on_run(self):
res = None
# 定义三个列表,存储成功,失败,未执行的用例(case_id)
pass_count = []
fail_count = []
no_run_count = []
# 每次执行用例之前将log日志文件清空数据
log_file = "D:\GZRJ\Python_XM\\api_automation_test\log\log.txt"
with open(log_file,'w') as f:
f.seek(0,0) # 加上f.seek(0)，把文件定位到position 0;没有这句的话，文件是定位到数据最后，truncate也是从最后这里删除
f.truncate()
# 先获取excel表格的行数
row_count = self.data.get_case_lines()
print("start_用例开始执行,请稍候.....")
for i in range(1, row_count): # 每循环一次，拿一次接口的所有数据
try:
# 先拿到is_run判断是否执行,如果是yes(会返回Ture),就去拿其它数据
is_run = self.data.get_is_run(i)
if is_run == True:
method = self.data.get_request_method(i)
url = self.data.get_request_url(i)
data = self.data.get_data_for_json(i)
header_key = self.data.is_header(i) # 获取excel文件中header关键字
header = self.data.get_header_value(i) # 获取json文件中header_key对应的头文件数据
expect = self.data.get_expcet_data(i) # 这里拿到的预期结果是字符串
# expect = self.data.get_expcet_data_for_mysql(i) # 断言方法如果是is_equal_dict就要取数据库这个值
depend_case = self.data.is_depend(i) # 获取依赖case_id
# 判断是否有依赖id，然后把返回数据替换到请求数据
if depend_case != None:
self.depend_data = DependdetData(depend_case)
# 1.获取依赖的响应字段数据
depend_response_data = self.depend_data.get_data_for_key(i)
# 2.获取需要替换的字段
depend_key = self.data.get_depend_field(i)
# 3.把1步拿到的values去替换第2步拿到的字段
data[depend_key] = depend_response_data
# 判断是否要写入,获取cookie
if header_key == "write_Cookies":
res = self.run_method.run_main(method, url, data, header, params=data)
op_header = OperationHeader(res)
op_header.write_cookie()
res = res.json() # 先获取cookies再转成json字典类型,不然后面无法和预期结果对比
elif header_key == "get_Cookies":
op_json = OperationJson("D:\GZRJ\Python_XM\\api_automation_test\dataconfig\cookie.json")
cookie = op_json.get_data("PHPSESSID")
cookies = {"PHPSESSID": cookie}
#print(cookies)
res = self.run_method.run_main(method, url, data, header, params=data, cookies=cookies).json()
else:
res = self.run_method.run_main(method, url, data, header, params=data).json()
#print(res)
#print(res["data"]["accessToken"])
# 判断预期结果是否在返回结果里面，需要把返回结果res转成json字符串中文和预期结果比较
if self.com_util.is_contain(expect, json.dumps(res, ensure_ascii=False)):
self.data.write_result(i, "pass")
pass_count.append(i)
else:
self.data.write_result(i, json.dumps(res, ensure_ascii=False))
with open(log_file, 'a', encoding='utf-8') as f:
f.write("\n第%s条用例实际结果与预期结果不一致:\n" % i)
f.write("Expected:%s\n Actual:%s\n" % (expect, res))
fail_count.append(i)
# 如果is_run是no,会返回False,然后把当前的case_id(行号)写入no_run_count
else:
no_run_count.append(i)
except Exception as e:
# 将异常写入excel的测试结果中
self.data.write_result(i, str(e))
# 将报错写入指定路径的日志文件里
with open(log_file, 'a', encoding='utf-8') as f:
f.write("\n第%s条用例报错:\n" % i)
initLogging(log_file, e)
fail_count.append(i)
"""
if self.com_util.is_equal_dict(expect, res):
self.data.write_result(i, "PASS")
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
"""
#我这里打印了一下用例的执行情况，嘿嘿
print("end_用例执行完毕！")
print("成功的用例：%s" % pass_count)
print("失败的用例：%s" % fail_count)
def get_data_for_json(self, row):
opera_json = OperationJson()
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
class GetData:
def __init__(self):
self.opera_excel = OperationExcel()
self.opera_json = OperationJson()
#获取excel行数，
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_value(row, col)
if run_model == 'yes':
flag = True
else:
flag = False
return flag
#是否携带hearder
def is_header(self, row):
col = int(data_config.get_header())
header = self.opera_excel.get_cell_value(row, col)
if header == 'yes':
headerJson = data_config.get_header_value()
return headerJson
else:
return None
#获取请求方式
def get_request_method(self, row):
col = int(data_config.get_run_way())
request_method = self.opera_excel.get_cell_value(row, col)
return request_method
#获取url
def get_request_url(self, row):
col = int(data_config.get_url())
url = self.opera_excel.get_cell_value(row, col)
return url
#获取请求数据
def get_request_data(self, row):
col = int(data_config.get_data())
data = self.opera_excel.get_cell_value(row, col)
if data == '':
return None
return data
#通过获取关键字拿到data数据
def get_data_for_json(self, row):
res = self.get_request_data(row)
request_data = self.opera_json.get_data(res)
return request_data
#获取预期结果
def get_expcet_data(self, row):
col = int(data_config.get_expect())
expect = self.opera_excel.get_cell_value(row, col)
if expect == '':
return None
else:
return expect
#结果写入
def write_res(self, row, value):
col = int(data_config.get_result_value())
self.opera_excel.write_value(row, col, value)
#状态写入
def write_status(self, row, value):
col = int(data_config.get_result())
self.opera_excel.write_value(row, col, value)
def get_case_depend(self, row):
case_col = int(data_config.get_case_depend())
case = self.opera_excel.get_cell_value(row, case_col)
rowRes = self.opera_excel.get_cell_row(case)
res = None
if rowRes:
result_col = int(data_config.get_result_value())
resData = self.opera_excel.get_value(rowRes, result_col)
if resData:
resData = json.loads(resData)
data_col = int(data_config.get_data_depend())
data = self.opera_excel.get_cell_value(row, data_col)
field_col = int(data_config.get_field_depend())
field = self.opera_excel.get_cell_value(row, field_col)
if field:
res = resData[data][field]
else:
res = resData[data]
return res
def get_json_data(self, row):
operation = OperationJson()
json_data = operation.get_data(self.get_request_data(row))
return json_data
def go_no_run(self):
rows_conut = self.data.get_case_lines() # 获取行数
for i in range(1, rows_conut):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_url(i)
case_name = self.data.get_case_name(i)
method = self.data.get_request_way(i) # 获取请求的方法
request_data = self.data.get_json_data(i) # 获取请求数据
data_type = self.data.get_data_type(i)
cookie = self.data.get_is_cookies(i) # 获取cookies
expect = self.data.get_expect(i) # 获取预期结果
depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid
if depend_case is not None:
# 获取替换请求字段
depend_key = self.data.get_depned_key(i)
# 获取依赖的响应数据
self.depend_data = DependData(depend_case)
depend_response_data = self.depend_data.get_depned_value(i)
split = len(depend_key.split(">")) # 切割替换的字段
# 根据请求字段的个数替换
for y in range(0, split):
re = depend_key.split(">")
request_data[re[y]] = depend_response_data[y]
if cookie == 'write':
res = self.run_method.run_main(method, url, request_data)
op_cookie = WriteCookies(res) # 获取cookies
op_cookie.write_cookie() # 写入cook ies
elif cookie == 'yes':
father_path = os.path.join(
os.path.dirname(
os.path.dirname(os.path.abspath(__file__))),
'data')
file_path = os.path.join(father_path, '金城-cookies.json')
get_cookies = OperationJson(file_path)
cooki = get_cookies.get_data('accessToken')
request_data['accessToken'] = cooki
res = self.run_method.run_main(method, url, request_data,
data_type)
else:
father_path = os.path.join(
os.path.dirname(
os.path.dirname(os.path.abspath(__file__))),
'data')
file_path = os.path.join(father_path, '金城-cookies.json')
get_cookies = OperationJson(file_path)
cooki = get_cookies.get_data('accessToken')
request_data['accessToken'] = cooki
res = self.run_method.run_main(method, url, request_data)
if self.is_contain.is_contain(expect, res):
self.data.write_data(i, 'pass')
# self.logger.info("第" + str(i) + "个case-->" + case_name + ": \033[31m测试通过\033[0m")
self.logger.info("第%s 个case-->%s: 测试通过" %
(str(i), case_name))
self.logger.info("url--> " + url)
self.logger.info("request_data-->" + str(request_data))
self.logger.info("response_data-->" + res)
print("第" + str(i) + "个case-->" + case_name + ": 测试通过")
# print("第" + str(i) + "个case-->" + case_name + ": \033[32m测试通过\033[0m")
else:
self.data.write_data(i, res)
self.logger.info("第" + str(i) + "个case-->" + case_name +
": 测试失败")
self.logger.info("url--> " + url)
self.logger.info("request_data-->" + str(request_data))
self.logger.info("response_data-->" + res)
# print("第" + str(i) + "个case-->" + "\033[35m测试失败\033[0m")
print("第%s 个case-->%s: 测试失败" % (str(i), case_name))
def get_data_value(self, row):
oper_json = OperationJson(
r'E:\pyScript\python3_interface-master\dataconfig\request_data.json'
)
request_data = oper_json.get_data(self.get_request_data(row))
return request_data
def go_on_run(self):
"""程序执行"""
pass_count = []
fail_count = []
no_run_count = []
res = None
# 获取用例数
rows_count = self.data.get_case_lines()
print(rows_count)
# 第一行索引为0
for i in range(1, rows_count):
print("i:", i)
is_run = self.data.get_is_run(i)
print(is_run)
if is_run:
url = self.data.get_request_url(i)
print("url:", url)
method = self.data.get_request_method(i)
print("method:", method)
request_data = self.data.get_data_for_json(i)
print("request_data:", request_data)
print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$", type(request_data))
expect = self.data.get_expect_data(i)
print("expect:", expect)
header = self.data.is_header(i)
print("header:", header)
token = self.data.is_token(i)
print("token:", token)
depend_case = self.data.is_depend(i)
print("depend_case:", depend_case)
if depend_case != None:
self.depend_data = DependentData(depend_case)
# 获取依赖的响应数据
print("#### i", i)
depend_response_data = self.depend_data.get_data_for_key(i)
print("##################")
print("1depend_response_data:", depend_response_data)
# 获取依赖的key
depend_key = self.data.get_depend_field(i)
print("depend_key:", depend_key)
# 更新请求字段
request_data.get(
'params')[depend_key] = depend_response_data
#request_data = json.dumps(request_data, ensure_ascii=False)
print("request_data:", request_data)
print(type(request_data))
# 如果header字段值为write则将该接口的返回的token写入到token.json文件，如果为yes则读取token.json文件
if header == "write_token":
print("********************")
res = self.run_method.run_main(method, url,
request_data).json()
print("res:", res)
print("res type", type(res))
#print("res.json():", res.json())
op_header = OperationHeader(res)
op_header.write_token()
elif header == 'write_cookie' and token == 'yes':
print("case22222222222222")
op_json = OperationJson("../dataconfig/token.json")
token = op_json.get_data('data')
request_data = dict(request_data,
**token) # 把请求数据与登录token合并，并作为请求数据
print("login_data", request_data)
res = self.run_method.run_main(method, url, request_data)
print("res_login:"******"@@@@@@@@@@@@@@@@@@@@@@@@@@")
op_json1 = OperationJson('../dataconfig/cookie.json')
op_json2 = OperationJson('../dataconfig/token.json')
cookies = op_json1.get_data('cookie')
token = op_json2.get_data('data')
request_data = dict(request_data, **token)
print("post_data:", request_data)
print("cookie:", cookies)
new_value = json.dumps(request_data.get("params"))
request_data["params"] = new_value
res = self.run_method.run_main(method,
url,
request_data,
cookies=cookies)
print("res:", type(res))
else:
res = self.run_method.run_main(method, url, request_data)
if expect != None:
if self.com_util.is_contain(expect, res):
self.data.write_result(i, "Pass")
pass_count.append(i)
if type(res) is dict:
self.data.write_real_res(i, json.dumps(res))
else:
self.data.write_real_res(i, json.dumps(res.json()))
else:
self.data.write_result(i, "Fail")
fail_count.append(i)
if type(res) is dict:
self.data.write_real_res(i, json.dumps(res))
else:
self.data.write_real_res(i, json.dumps(res.json()))
else:
print(f"用例ID：case-{i}，预期结果不能为空")
else:
self.data.write_result(i, "Not run")
no_run_count.append(i)
# 发送邮件
print(f"通过用例数：{len(pass_count)}")
print(f"失败用例数：{len(fail_count)}")
print(f"未执行败用例数：{len(no_run_count)}")
self.send_email.send_main(pass_count, fail_count, no_run_count)
