def get_data_for_json(self, row):
opera_json = OperetionJson()
if opera_json.get_data(self.get_request_data(row)) == None:
request_data = ""
else:
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
def get_data_for_json(self, row):
opera_json = OperetionJson()
data = self.get_request_data(row)
if data == None:
data = '{"a":"1"}'
print(data)
return opera_json.get_data(data)
def run_dependent(self):
run_method = RunMethod()
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)
header = self.data.is_header(row_num)
url = self.data.get_request_url(row_num)
files = {'file': (
'new1.xlsx', open("C:\\Users\\Aaron\\Desktop\\new1.xlsx", 'rb'), 'application/vnd.ms-excel')}
if header == "yes":
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {
'apsid': cookie
}
headers1 = op_json.get_data('Authorization')
headers = {
'Authorization': headers1
}
res = run_method.run_main(method, url,request_data,headers,files,cookies)
else:
res = run_method.run_main(method,url,request_data)
return json.loads(res)
def get_data_for_json(self, row):
opera_json = OperetionJson()
date = self.get_request_data(row)
if date:
request_data = opera_json.get_data(date)
return request_data
else:
return None
def get_data_for_json(self, row):
if not row:
return None
opera_json = OperetionJson()
request_data = opera_json.get_data(self.get_request_data(row))
# if not request_data:
# return None
# else:
return request_data
def get_request_data(self, row):
col = int(data_config.get_data())
data = self.opera_excel.get_cell_value(row, col)
if data == '':
request_data = None
else:
opera_json = OperetionJson()
request_data = opera_json.get_data(data)
return request_data
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
if re.match('{.+}', data, re.M | re.I) == None:
opera_json = OperetionJson()
data = opera_json.get_data(data)
return self.find_def(data)
def go_on_run(self):
res = None
pass_count = []
fail_count = []
#10 0,1,2,3
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)
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 = 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 == 'write':
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
res = self.run_method.run_main(method, url, request_data,
cookies)
else:
res = self.run_method.run_main(method, url, request_data)
print(res)
print(type(res))
#if self.com_util.is_equal_dict(expect,res) == 0:
#if self.com_util.is_contains_dict(expect,res):
if self.com_util.is_contain(expect, res):
self.data.write_result(i, 'pass')
pass_count.append(i)
res = pass_count
else:
#self.data.write_result(i,res)
self.data.write_result(i, 'fail')
fail_count.append(i)
res = fail_count
def go_on_run(self):
res = None
pass_count = []
fail_count = []
# 10 0,1,2,3
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(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)
#print(request_data)
#request_data[depend_key] = depend_response_data
request_data = self.operation.deal_data(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 = OperetionJson('config/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {
'apsid': cookie
}
res = self.run_method.run_main(method, url, request_data, cookies)
else:
res = self.run_method.run_main(method, url, request_data, {'Content-Type': 'application/x-www-form-urlencoded'})
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)
self.send_mai.send_email(pass_count, fail_count)
def go_on_run(self):
res = None
pass_count = []
fail_count = []
#10 0,1,2,3
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(i)
header = self.data.is_header(i)
depend_case = self.data.is_depend(i)
case_name = self.data.get_case_name(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 == 'write':
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperetionJson('./dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
# cookies = {
# 'apsid':cookie
# }
res = self.run_method.run_main(method, url, request_data,
cookie)
self.logger.info("用例名称:" + case_name + "--->返回值:" + res)
#print(res)
else:
res = self.run_method.run_main(method, url, request_data)
self.logger.info("用例名称:" + case_name + "--->返回值:" + res)
#print(res)
if self.com_util.is_contain(expect, res) == True:
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
#self.send_mai.send_main(pass_count,fail_count) #不带文件发送
self.send_email.sendemail(pass_count, fail_count) #带文件发送
def run_dependent(self):
run_method = RunMethod()
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 = run_method.run_main(method,url,request_data)
res = None
if header == "yes":
op_json = OperetionJson('./dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
res = run_method.run_main(method, url, request_data, cookie)
else:
res = run_method.run_main(method, url, request_data)
return json.loads(res)
def __init__(self, methodName='runTest', parame=None):
super(ParameTestCase, self).__init__(methodName)
self.run_method = RunMethod()
self.data = GetData()
self.com_util = CommonUtil()
self.send_mai = SendEmail()
self.operation = OperetionJson()
def go_on_run(self):
res = None
pass_count = []
fail_count = []
#10 0,1,2,3
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)
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 = 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 == 'write':
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
res = self.run_method.run_main(method, url, request_data,
cookies)
else:
res = self.run_method.run_main(method, url, request_data)
# print(res["data"][2]["context"])
print(res)
# print(type(res))
#自己写的：这个是判断字段是否在结果中
if expect in res:
self.data.write_result(i, "pass")
pass_count.append(i)
else:
self.data.write_result(i, "fail")
fail_count.append(i)
def test_main(self, sheet_name, case_name, sheet_id, case_id):
self.data = GetData(sheet_id)
is_run = self.data.get_is_run(case_id)
if is_run:
url = self.data.get_request_url(case_id)
method = self.data.get_request_method(case_id)
#request_data = self.data.get_data_for_json(i)
request_data = self.data.get_request_data(case_id)
# expect = self.data.get_expcet_data_for_mysql(i)
expect = self.data.get_expcet_data(case_id)
header = self.data.is_header(case_id)
depend_case = self.data.is_depend(case_id)
if depend_case != None:
self.depend_data = DependdentData(sheet_id, depend_case)
# 获取的依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(case_id)
# 获取依赖的key
depend_key = self.data.get_depend_field(case_id)
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 = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {
'apsid': cookie
}
res = self.run_method.run_main(method, url, request_data, cookies)
else:
res = self.run_method.run_main(method, url, request_data)
print(res)
if self.com_util.is_contain(expect, res):
self.data.write_result(case_id,'pass')
else:
self.data.write_result(case_id, res)
#self.assertIn(expect,res,"预期结果：{0} 未在实际返回结果：{1} 中！ ".format(expect,res))
#添加最后结果时间戳
self.data.write_result(0, '实际结果 {}'.format(time.strftime("%Y_%m_%d_%H_%M_%S")))
self.assertIn(expect,res)
def go_on_run(self):
res = None
pass_count = []
fail_count = []
# 10 0,1,2,3
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)
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 == 'write':
res = self.run_method.run_main(method, url, request_data)
op_header = OperationHeader(res)
op_header.write_cookie()
elif header == 'yes':
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {
'apsid': cookie
}
res = self.run_method.run_main(method, url, request_data, cookies)
else:
res = self.run_method.run_main(method, url, request_data)
if self.com_util.is_equal_dict(expect, res) == 0:
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
self.send_mai.send_main(pass_count, fail_count)
class GetExcelDataOfJson:
def __init__(self):
pass
def get_json_of_excel(self):
#通过jsonOfExcel.json文件获取要执行的excel名字，如果在字典中该key对应的value是yes的话，就读取这个excel
self.get_json_of_excel = OperetionJson(
'../dataconfig/jsonOfExcel.json')
getJsonOfExcel = self.get_json_of_excel.read_data()
return getJsonOfExcel
def is_header(self, row):
col = int(data_config.get_header())
header = self.opera_excel.get_cell_value(row, col)
if header != '':
if header == 'write':
return header
elif header == 'yes':
op_json = OperetionJson('../dataconfig/cookie.json')
# cookie = op_json.get_data('apsid')
# cookies = {
# 'apsid':cookie
# }
cookies = op_json.get_data('header')
# cookies = {
# 'token':cookie,
#
# }
return cookies
else:
return None
else:
return None
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
# 替换
p = r"\${(.+?)}"
robocop = re.compile(p, re.I)
temps = robocop.findall(expect)
if temps:
for temp in temps:
# 数据库查询,不区分大小写
if temp.upper().find("select".upper()) >= 0:
op_mysql = OperationMysql()
res = op_mysql.search_one(temp)
expect = re.sub(p, res, expect)
# json替换
else:
opera_json = OperetionJson()
res = str(opera_json.get_data(temp))
expect = re.sub(p, res, expect)
return expect
def run_dependent(self):
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
depend_case = self.data.is_depend(row_num)
method = self.data.get_request_method(row_num)
if depend_case is not None:
self.depend_data = DependdentData(depend_case)
# 获取的依赖响应数据
# for depend_response_data_list in
depend_response_data = self.depend_data.get_data_for_key(row_num)
if len(depend_response_data) == 1:
request_data_result = "".join(depend_response_data)
else:
request_data_result = ",".join(
[str(i) for i in depend_response_data])
# 获取依赖的key
depend_key = self.data.get_depend_field(row_num)
depend_key_list = depend_key.split(",")
for (key_list, key) in zip(request_data_result.split(","),
depend_key_list):
# print(key_list, key)
if method == "Post" or method == "Get":
# print(key)
request_data[key] = key_list
else:
request_data = depend_response_data
break
# print("依赖request_data===========%s" % request_data)
header = self.data.is_header(row_num)
op_json = OperetionJson('../dataconfig/weChatToken')
contentType = "application/json"
token = op_json.get_data('token')
if header == 'write':
header = {'Content-Type': contentType}
elif header == 'yes':
op_json = OperetionJson('../dataconfig/token.json')
token = op_json.get_data('token')
header = {'Content-Type': contentType, 'Authorization': token}
elif header == 'weChat':
header = {'Content-Type': contentType, "Authorization": token}
# print(header)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
res = run_method.run_main(method, url, request_data, header)
return json.loads(res)
def write_cookie(self):
cookie = requests.utils.dict_from_cookiejar(self.get_cookie())
op_json = OperetionJson()
op_json.write_data(cookie)
def write_user_token(self):
token = self.get_token()
op_json = OperetionJson()
op_json.write_user_data(token)
def go_on_run(self):
res = None
pass_count = []
fail_count = []
#10 0,1,2,3
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)
expect = self.data.get_expcet_data(i)
# print("except data is %s" %expect)
header = self.data.is_header(i)
depend_case = self.data.is_depend(i)
response_value = self.data.get_response_result_field(i)
is_post_previous_case = self.data.get_post_result(i)
depend_excel_file = self.data.is_excel(i)
if depend_case == None:
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 = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
headers1 = op_json.get_data('Authorization')
headers = {'Authorization': headers1}
if depend_excel_file == 'Y':
files = {
'file':
('new1.xlsx',
open("C:\\Users\\Aaron\\Desktop\\new1.xlsx",
'rb'), 'application/vnd.ms-excel')
}
res = self.run_method.run_main(
method, url, request_data, headers, files,
cookies)
else:
convert_data = json.dumps(request_data)
res = self.run_method.run_main(method,
url=url,
data=convert_data,
headers=headers,
cookies=cookies)
else:
res = self.run_method.run_main(method, url,
request_data)
# res = self.run_method.run_main(method, url, request_data)
elif depend_case == "write":
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 = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
headers1 = op_json.get_data('Authorization')
headers = {'Authorization': headers1}
if depend_excel_file == 'Y':
files = {
'file':
('new1.xlsx',
open("C:\\Users\\Aaron\\Desktop\\new1.xlsx",
'rb'), 'application/vnd.ms-excel')
}
res = self.run_method.run_main(
method, url, request_data, headers, files,
cookies)
else:
res = self.run_method.run_main(
method, url, request_data, headers, cookies)
else:
res = self.run_method.run_main(method, url,
request_data)
# res = self.run_method.run_main(method, url, request_data)
self.data.write_response_to_cell(
i, res.content.decode("utf-8"))
else:
self.depend_data = DependdentData(depend_case)
# 获取依赖的key
depend_key = self.data.get_depend_field(i)
if is_post_previous_case == 'N':
depend_response_data = self.depend_data.get_data_for_excel(
i)
else:
#获取的依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(
i)
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 = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('apsid')
cookies = {'apsid': cookie}
headers1 = op_json.get_data('Authorization')
headers = {'Authorization': headers1}
files = {
'file':
('new1.xlsx',
open("C:\\Users\\Aaron\\Desktop\\new1.xlsx",
'rb'), 'application/vnd.ms-excel')
}
request_data = json.dumps(request_data)
print(type(request_data))
res = self.run_method.run_main(method,
url=url,
data=request_data,
headers=headers,
cookies=cookies)
else:
res = self.run_method.run_main(method, url,
request_data)
# if depend_case == "write":
# self.data.write_response_to_cell(i,res.decode("utf-8"))
# if self.com_util.is_equal_dict(expect,json.dumps(res)) == 0:
if self.com_util.is_contain(
expect, res.content.decode("utf-8")) == True:
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
# self.data.write_result(i,json.dumps(res,ensure_ascii=False))
self.data.write_result(i, res.content.decode("utf-8"))
fail_count.append(i)
self.send_mai.send_main(pass_count, fail_count)
def go_on_run(self):
count_all_case = 0
count_all_case_detail = []
count_yes_case = 0
count_yes_case_detail = []
count_no_case = 0
count_no_case_detail = []
pass_count = []
fail_count = []
#通过data_json_of_excel来获取json文件里面保存的excel文件名，然后根据字典里面的value值是否为yes来确定执行相应的excel
get_json_of_excel = self.data_json_of_excel.get_json_of_excel()
#这里的for循环是为了控制遍历执行json文件中的所有需执行的excel文件
for jsonOfExcelDict in get_json_of_excel:
if get_json_of_excel[jsonOfExcelDict].lower() == 'yes':
excel_path = '../dataconfig/' + jsonOfExcelDict + '.xls'
self.data = GetData(excel_path, 0)
self.run_method.setExcelPathName(excel_path)
else:
continue
res = None
#10 0,1,2,3
rows_count = self.data.get_case_lines()
#置空上次接口测试的结果
# for i in range(1, rows_count):
# self.data.write_void_to_output_cell(i, " ")
# print(self.data.get_case_name(i))
#开始接口测试
for i in range(1, rows_count):
count_all_case += 1
is_run = self.data.get_is_run(i)
if is_run:
count_yes_case += 1
case_id = self.data.get_case_id(i)
case_name = self.data.get_case_name(i)
# 显示当前正在执行的case的id和name，用来在报错的时候定位是那一条case出问题了
print("ID：\n{}\n接口名称：{}\n调用表路径：{}".format(
case_id, case_name, excel_path))
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
request_data = self.data.get_data_for_json(i)
#这是mss老师当时把预期结果里面的sql语111句查询出来，然后返回到expect里面的写法
# expect = self.data.get_one_sql_data(i, self.data.get_expcet_data)
expect = self.data.get_expcet_data(i)
# RunTestPrint
# print(expect)
# print(type(expect))
header = self.data.is_header(i)
depend_case = self.data.is_depend(i)
depend_case_sql = self.data.is_depend_sql(i)
if depend_case != None:
self.depend_data = DependdentData(
depend_case, excel_path, 0)
#获取的依赖响应数据
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 depend_case_sql != None:
#获取的sql查询依赖数据
depend_sql_results = self.data.get_one_sql_data(
i, self.data.get_sql_rely_result_data)
#如果depend_sql_results的值为null说明这段sql语句没有查询出结果，比如我在做某个用户新增之前我需要先删除，
#但是如果该用户根本都没有的话，那么就删除不了，这时候就需要这里的if来判断
if depend_sql_results != "null":
#把unicode格式的字典改为json格式
depend_sql_results = json.loads(depend_sql_results)
#通过循环把字典数据里面的value取出来
for key in depend_sql_results:
depend_sql_result = depend_sql_results[key]
#获取依赖的key
depend_key = self.data.get_depend_field(i)
request_data[depend_key] = depend_sql_result
if header == 'write':
res = self.run_method.run_main(method, url,
request_data)
op_header = OperationHeader(res)
op_header.write_header()
elif header == 'yes':
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('token')
cookies = {"Authorization": cookie}
try:
res = self.run_method.run_main(
method, url, request_data, cookies)
except json.decoder.JSONDecodeError:
# 如果出现json.decoder.JSONDecodeError的报错的话，就走到这里，然后把响应的模块清空
# 这样子的话我就知道哪些模块出错了，或者说知道哪些模块没有执行
self.data.write_void_to_output_cell(i, " ")
print(self.data.get_case_name(i))
continue
else:
try:
res = self.run_method.run_main(
method, url, request_data)
except json.decoder.JSONDecodeError:
# 如果出现json.decoder.JSONDecodeError的报错的话，就走到这里，然后把响应的模块清空
# 这样子的话我就知道哪些模块出错了，或者说知道哪些模块没有执行
self.data.write_void_to_output_cell(i, " ")
print(self.data.get_case_name(i))
continue
#写响应结果返回值到返回状态列
self.data.write_code_responde_result(
i,
json.loads(res)['code'])
#写请求数据内容到请求数据内容列
self.data.write_request_data_result(
i, json.dumps(request_data, ensure_ascii=False))
#判断预期结果和实际结果是否一致，并将结果填入excel
if self.com_util.is_equal_dict2(expect, res) == True:
self.data.write_result_status(i, 'pass')
self.data.write_result(i, res)
pass_count.append(i)
else:
self.data.write_result_status(i, 'fail')
self.data.write_result(i, res)
fail_count.append(i)
sql_result = self.data.get_all_sql_data(
i, self.data.get_sql_result_data)
self.data.write_sql_result(i, sql_result)
else:
count_no_case_detail.append(self.data.get_case_name(i))
self.send_mai.send_main(pass_count, fail_count, "OA项目所有空参数测试点")
print('所有case条数为：{}条；\n运行了的case条数为{}条；\n没有运行的case条数为{}条.'.format(
count_all_case, count_yes_case, count_all_case - count_yes_case))
print('(因为登录模块多执行了9次，所以所有case真是条数条数应该为{}-9={})'.format(
count_all_case, count_all_case - 9))
print('没有运行的case是：')
for case_detail in count_no_case_detail:
print(case_detail)
def get_data_for_json(self, row):
opera_json = OperetionJson('config/user.json')
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
def write_cookie(self):
#cookie = requests.utils.dict_from_cookiejar(self.get_cookie())
cookie = self.get_cookie()
cookies = {"apsid": {"Authorization": "Bearer %s" % (cookie)}}
op_json = OperetionJson()
op_json.write_data(cookies)
def go_on_run(self):
global expect
expect = True
res = None
pass_count = []
fail_count = []
# 10 0,1,2,3
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)
expect = self.data.get_expcet_data(i)
header = self.data.is_header(i)
depend_case = self.data.is_depend(i)
if depend_case is not None:
self.depend_data = DependdentData(depend_case)
# 获取的依赖响应数据
# for depend_response_data_list in
depend_response_data = self.depend_data.get_data_for_key(i)
if len(depend_response_data) == 1:
request_data_result = "".join(depend_response_data)
else:
request_data_result = ",".join(
[str(i) for i in depend_response_data])
# 获取依赖的key
depend_key = self.data.get_depend_field(i)
depend_key_list = depend_key.split(",")
print(type(depend_key_list))
for (key_list, key) in zip(request_data_result.split(","),
depend_key_list):
print(key_list, key)
if method == "Post" or method == "Get" or method == "Put_Add" or method == "Put":
# print(key)
request_data[key] = key_list
else:
request_data = depend_response_data
break
contentType = "application/json"
if header == 'write':
header = {'Content-Type': contentType}
res = self.run_method.run_main(method,
url,
data=request_data,
header=header)
op_header = OperationHeader(res)
op_header.write_token()
elif header == 'yes':
op_json = OperetionJson('../dataconfig/token.json')
token = op_json.get_data('token')
header = {
'Content-Type': contentType,
'Authorization': token
}
# print("request_data=======%s" % request_data)
res = self.run_method.run_main(method,
url,
request_data,
header=header)
elif header == 'write_user':
header = {
'Content-Type': contentType,
}
res = self.run_method.run_main(method,
url,
request_data,
header=header)
op_header = OperationHeader(res)
op_header.write_user_token()
elif header == 'weChat':
op_json = OperetionJson('../dataconfig/weChatToken')
token = op_json.get_data('token')
header = {
'Content-Type': contentType,
'Authorization': token
}
res = self.run_method.run_main(method,
url,
request_data,
header=header)
else:
res = self.run_method.run_main(method, url, request_data)
if self.com_util.is_contain(expect, res) == 0:
self.data.write_result(i, 'pass')
pass_count.append(i)
else:
self.data.write_result(i, res)
fail_count.append(i)
/proxy/query
/proxy/querybatch
'''
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from util.operation_json import OperetionJson
from util.operation_db import OperationDB
from base.base_method import BaseMethod
import unittest
import requests
run_method = BaseMethod()
opera_json = OperetionJson()
opera_db = OperationDB()
class TestProxyCreate(unittest.TestCase):
def test01_proxy_create_success(self):
"""case01:创建方法--创建GET方法"""
api = '/proxy/create'
data = {"URL": "https://www.baidu.com", "name": "auto_test"}
res = run_method.post(api, json=data)
self.assertEqual(res.status_code, 200, run_method.errInfo(res))
# 存入ID，后面做数据清除
opera_json.check_json_value("test01_proxy_create", res.json()["id"])
@classmethod
def get_data_for_json(self, row):
# 通过json_path单元格获取制定的json模块的data(excel的json路径列)
json_path = self.get_path_json(row)
opera_json = OperetionJson(json_path)
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
with open(r"../dataconfig/err500list.txt", "a+") as err500list:
# self.setExcelPathName("测试测试")
new_500_error = '---------\n' + self.getExcelPathName(
) + '\n' + str(datetime.datetime.now()) + '\n' + str(
res.status_code) + '\n' + url + '\n'
err500list.write(new_500_error)
def getExcelPathName(self):
return self.excelPathName
def setExcelPathName(self, excelPathName):
self.excelPathName = excelPathName
if __name__ == '__main__':
op_json = OperetionJson('../dataconfig/cookie.json')
cookie = op_json.get_data('token')
headers = {"Content-Type": "application/json", "Authorization": cookie}
createobs1Url = 'http://oa.jc-saas.com.cn/obs/add'
cba1 = {
"parent_id": '4',
"obs_name": "jesseTest部门添加23",
"isno_company": '1',
"obs_abbreviation": "",
"duty_staff_work_number": "",
"establish_time": "",
"plan_staff_num": "",
"note": "",
"company_name": "",
"company_type": "",
def get_data_for_json(self, row):
opera_json = OperetionJson()
request_data = opera_json.get_data(self.get_request_data(row))
return request_data
return res.json()
def get_main(self, url, data=None, header=None):
res = None
if header != None:
res = requests.get(url=url,
data=data,
headers=header,
verify=False)
else:
res = requests.get(url=url, data=data, verify=False)
return res.json()
def run_main(self, method, url, data=None, header=None):
res = None
if method == 'Post':
res = self.post_main(url, data, header)
else:
res = self.get_main(url, data, header)
return json.dumps(res, ensure_ascii=False)
if __name__ == '__main__':
runMethod = RunMethod()
jsonAction = OperetionJson()
result = runMethod.run_main('Post',
'http://m.imooc.com/passport/user/login',
jsonAction.get_data('user'))
print(result)
pass
