class RunTest:
def __init__(self):
self.run_method = RunMethod()
self.data = GetData()
self.common_util = CommonUtil()
self.email = SendEmail()
def go_on_run(self):
"""获取用例行数"""
row_count = self.data.get_case_line()
print("用例行数:", row_count)
pass_count = []
fail_count = []
#循环执行用例
for i in range(1, row_count):
is_run = self.data.get_is_run(i)
print("i的值:", i)
print("is_run:", is_run)
if is_run:
url = self.data.get_url(i)
print("url:", url)
request_type = self.data.get_request_type(i)
print("request_type:", request_type)
data = self.data.get_data_for_json(i)
print("data:", data)
#dependent_case = self.data.is_depend(i)
dependent_more_case = self.data.is_more_depend(i, 0)
print("dependent_more_case:", dependent_more_case)
if dependent_more_case != None:
self.dependent_data = DependentData(dependent_more_case)
#获取依赖的响应数据
dependent_response_data = self.dependent_data.get_data_for_key(
i, 0)
print("dependent_response_data", dependent_response_data)
token_value = self.common_util.getToken(0)
token_header = self.data.get_token_header(i, token_value)
print("token_header:", token_header)
if url == "http://182.61.33.241:8089/app/api/private/1.0/client/":
new_url = url + dependent_response_data
print("------------------------------------")
print("new_url:", new_url)
result = self.run_method.run_main(
request_type, new_url, data, token_header)
else:
#获取依赖的key
depend_key = self.data.get_dependent_key(i, 0)
print("depend_key", depend_key)
jsonData = json.loads(data)
print("data:", data)
jsonData[depend_key] = dependent_response_data
requestData = json.dumps(jsonData)
result = self.run_method.run_main(
request_type, url, requestData, token_header)
else:
if i == 1:
header = self.data.get_header(i)
print("header:", header)
#result = self.run_method.post_main(url, data, header)
result = self.run_method.run_main(
request_type, url, data, header)
res = json.loads(result)
#获取token值
with open(self.common_util.base_dir(), 'w') as f:
f.write(res["data"]["token"] + "," +
res["data"]["id"])
print("获取token：", res["data"]["token"])
else:
token_value = self.common_util.getToken(0)
token_header = self.data.get_token_header(
i, token_value)
if url == "http://182.61.33.241:8089/app/api/private/1.0/follow/clientpage":
oper_id = self.common_util.getToken(1)
jsonData = json.loads(data)
jsonData["operId"] = oper_id
request_data = json.dumps(jsonData)
result = self.run_method.run_main(
request_type, url, request_data, token_header)
else:
result = self.run_method.run_main(
request_type, url, data, token_header)
print("返回结果：", result)
except_res = self.data.get_except(i)
print("except_res:", except_res)
if self.common_util.is_contain(except_res, result):
self.data.write_result(i, "测试通过")
print("测试通过")
pass_count.append(i)
else:
self.data.write_result(i, "测试失败")
print("测试失败")
fail_count.append(i)
print("打印结果：", result)
print("通过数：", len(pass_count))
print("失败数：", len(fail_count))
# self.email.send_main(pass_count, fail_count)
return result
class GuestCase:
def __init__(self):
self.json_file = "/Users/mac/Desktop/测试资料/蜗牛家产品线/woniujia_cc_jiekou/woniujia_cc_jiekou_git/woniujia_cc_project/dataconfig/request_pram.json"
self.sheet_name = "客户模块"
self.sheet_id = 5
self.data = GetData(self.json_file, self.sheet_name, self.sheet_id)
self.run_method = RunMethod()
self.util = CommonUtil()
self.email = SendEmail()
def go_to_guest(self):
# self.run_comm = RunCommon(self.excel_file, self.json_file)
# self.run_comm.go_run_case()
# 获取用例行数
row_count = self.data.get_case_line()
pass_count = []
fail_count = []
for i in range(1, row_count):
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_url(i)
request_type = self.data.get_request_type(i)
data = self.data.get_data_for_json(i)
if i == 1:
header = self.data.get_header(i)
response = self.run_method.run_main(
request_type, url, data, header)
res = json.loads(response)
# 获取token、operid并写入文件中
with open(self.util.base_dir(), 'w') as f:
f.write(res["data"]["token"] + "," + res["data"]["id"])
else:
token = self.util.getToken(0)
token_header = self.data.get_token_header(i, token)
depend_morecase = self.data.is_more_depend(i, 0)
# 判断是否存在依赖
if depend_morecase != None:
self.depend_data = DependentData(
depend_morecase, self.excel_file, self.json_file)
dependent_response_data = self.depend_data.get_data_for_key(
i, 0)
depend_key = self.data.get_dependent_key(i, 0)
print("depend_key", depend_key)
if url == "http://182.61.33.241:8089/app/api/private/1.0/client/":
request_url = url + dependent_response_data
response = self.run_method.run_main(
request_type, request_url, data, token_header)
if url == "http://182.61.33.241:8089/app/api/private/1.0/reporting/addorupdate":
depend_param2 = self.data.is_more_depend(i, 1)
self.depend_data2 = DependentData(
depend_param2, self.excel_file, self.json_file)
dependent_response_data2 = self.depend_data2.get_data_for_key(
i, 1)
depend_key2 = self.data.get_dependent_key(i, 1)
jsonData = json.loads(data)
jsonData[depend_key] = dependent_response_data
jsonData[depend_key2] = dependent_response_data2
requestData = json.dumps(jsonData)
response = self.run_method.run_main(
request_type, url, requestData, token_header)
else:
jsonData = json.loads(data)
print("data:", data)
jsonData[depend_key] = dependent_response_data
requestData = json.dumps(jsonData)
response = self.run_method.run_main(
request_type, url, requestData, token_header)
else:
if url == "http://182.61.33.241:8089/app/api/private/1.0/follow/clientpage":
oper_id = self.util.getToken(1)
json_data = json.loads(data)
json_data["operId"] = oper_id
request_data = json.dumps(json_data)
response = self.run_method.run_main(
request_type, url, request_data, token_header)
else:
response = self.run_method.run_main(
request_type, url, data, token_header)
expect_res = self.data.get_except(i)
print("期望结果：", expect_res)
if self.util.is_contain(expect_res, response):
self.data.write_result(i, "测试通过", self.sheet_id)
pass_count.append(i)
print("测试通过")
else:
self.data.write_result(i, "测试失败", self.sheet_id)
fail_count.append(i)
print("测试失败")
self.data.write_response(i, response, self.sheet_id)
self.email.send_main(pass_count, fail_count)
return response
class Run:
def __init__(self, json_file, sheet_name, sheet_id, sql_base=None):
self.json_file = json_file
self.sheet_name = sheet_name
self.sheet_id = sheet_id
self.sql_base = sql_base
self.data = GetData(self.json_file, self.sheet_name)
self.run_method = RunMethod()
self.util = CommonUtil()
self.email = SendEmail()
# 连接数据库,查询某字段的所有记录、总数、页数
def get_sql_expect(self, i, sql_key):
token = self.util.getToken(0)
operid = self.util.getToken(1)
# token_header = self.data.get_token_header(i, token)
expect_res = self.data.get_except_data_for_sql(
i, self.sql_base) # 获取数据库返回的所有楼盘记录（返回类型：数组型）
expect_value_list = []
if len(expect_res) == 0:
count = 0
new_count = 1
return count, new_count, expect_value_list
else:
for expect_index in range(0, len(expect_res)):
expect_value = expect_res[expect_index][
sql_key] # 循环获取数据库返回的某个字段
expect_value_list.append(expect_value) # 将数据库中所有该字段存入该数组中
count = len(expect_value_list)
if count / 15 < 1:
new_count = 1
elif (count / 15) >= 1 and (count % 15) >= 1:
new_count = int(count / 15) + 1
else:
new_count = int(count / 15)
return count, new_count, expect_value_list
# 获取response
def is_depend(self, i, depend_morecase, request_type, url, token_header,
data):
# 判断是否存在依赖
if depend_morecase != None:
depend_data = DependentData(depend_morecase, self.sheet_name,
self.json_file)
dependent_response_data = depend_data.get_data_for_key(i, 0)
if request_type == "get":
request_url = url + dependent_response_data
response = self.run_method.run_main(request_type, request_url,
data, token_header)
else:
depend_key = self.data.get_dependent_key(i, 0)
jsonData = json.loads(data)
jsonData[depend_key] = dependent_response_data
requestData = json.dumps(jsonData)
response = self.run_method.run_main(
request_type, url, requestData,
token_header) # 获取接口返回数据（返回类型：string型）
else:
response = self.run_method.run_main(
request_type, url, data,
token_header) # 获取接口返回数据（返回类型：string型）
return response
# 判断expect表中记录和response列表记录是否相等，返回result是True或者False
def get_result(self, count, expect_value_list, response, response_key):
is_result = True
response_dict = json.loads(response) # 将response字符串型转换成字典型
# if self.type == "data":
# response_list = response_dict['data']
# elif self.type == "list":
# response_list = response_dict['data']['list']
response_dict_data = response_dict['data']
if 'list' in response_dict_data:
response_list = response_dict['data']['list']
else:
response_list = response_dict_data
if len(response_list) == count:
is_result = True
else:
for response_index in range(len(response_list)):
response_name = response_list[response_index][
response_key] # 循环获取接口返回的字段名称
if self.util.is_contain(
response_name,
expect_value_list): # 判断如果接口返回的xx字段存在数据库xx字段数组中，则测试通过
is_result = True
else:
is_result = False
return is_result
# 判断expect表中记录的总数和response中某字段的数量是否相等，返回result是True或者False
def get_result_count(self, count, response, response_key):
response_dict = json.loads(response) # 将response字符串型转换成字典型
response_opt = response_dict['data'][response_key]
if int(response_opt) == count:
result = True
else:
result = False
return result
# 写入实际结果
def write_result(self, fail_count, i, pass_count, result):
if result:
self.data.write_result(i, "测试通过", self.sheet_id)
pass_count.append(i)
print("测试通过")
else:
self.data.write_result(i, "测试失败", self.sheet_id)
fail_count.append(i)
print("测试失败")
# 执行用例
def go_to_run(self):
# 获取用例行数
row_count = self.data.get_case_line()
pass_count = []
fail_count = []
result = True
# 循环用例
for i in range(1, row_count):
# 获取isrun，是否运行该用例
is_run = self.data.get_is_run(i)
response_key = self.data.get_response_key(i)
sql_key = self.data.get_sql_key(i)
sql_type = self.data.get_sql_type(i)
if is_run:
url = self.data.get_url(i)
request_type = self.data.get_request_type(i)
is_connect = self.data.get_is_conn_db(
i) # 获取是否连接数据库，若是则执行sql，若不是直接获取期望结果
depend_morecase = self.data.is_more_depend(i, 0) # 获取依赖数据
data = self.data.get_data_for_json(i)
if is_connect:
token = self.util.getToken(0)
token_header = self.data.get_token_header(i, token)
# 获取预期结果
count = self.get_sql_expect(i, sql_key)[0] # 数据库查询结果记录总数
new_count = self.get_sql_expect(i,
sql_key)[1] # 获取接口执行次数，翻页
expect_value_list = self.get_sql_expect(
i, sql_key)[2] # 获取某个字段在表中的所有值
# 获取返回数据
response = self.is_depend(i, depend_morecase, request_type,
url, token_header, data)
if sql_type == "count":
# 比较接口返回的总数与数据库查询出的记录总数是否相等，相等返回True
actrual_result = self.get_result_count(
count, response, response_key)
else:
for n in range(1, new_count + 1):
data = self.data.get_data_for_newjson(
i, '"' + str(n) + '"')
# 比较预期结果和返回结果是否相等，相同返回result=True
actrual_result = self.get_result(
count, expect_value_list, response,
response_key)
self.write_result(fail_count, i, pass_count,
actrual_result)
else:
expect_res = self.data.get_except(i)
if i == 1:
header = self.data.get_header(i)
response = self.run_method.run_main(
request_type, url, data, header)
res = json.loads(response)
# 获取token、operid并写入文件中
with open(self.util.base_dir(), 'w') as f:
f.write(res["data"]["token"] + "," +
res["data"]["id"])
# print("获取token：", res["data"]["token"])
else:
token = self.util.getToken(0)
operid = self.util.getToken(1)
token_header = self.data.get_token_header(i, token)
response = self.is_depend(i, depend_morecase,
request_type, url,
token_header, data)
# response = self.run_method.run_main(request_type, url, data, token_header)
# print("返回结果：", response)
result = self.util.is_contain(expect_res, response)
self.write_result(fail_count, i, pass_count, result)
self.data.write_response(i, response, self.sheet_id)
# self.email.send_main(pass_count, fail_count)
return response
class RunCommon:
def __init__(self, json_file, sheet_name, sheet_id):
# self.excel_file = excel_file
self.json_file = json_file
self.sheet_name = sheet_name
self.sheet_id = sheet_id
self.data = GetData(self.json_file, self.sheet_name)
self.run_method = RunMethod()
self.util = CommonUtil()
self.email = SendEmail()
def go_run_case(self):
# 获取用例行数
row_count = self.data.get_case_line()
pass_count = []
fail_count = []
# 循环用例
for i in range(1, row_count):
# 获取isrun，是否运行该用例
is_run = self.data.get_is_run(i)
if is_run:
#model = self.data.get_model(i)
url = self.data.get_url(i)
data = self.data.get_data_for_json(i)
request_type = self.data.get_request_type(i)
if i == 1:
header = self.data.get_header(i)
#request_data = self.data.get_data_for_json(i)
response = self.run_method.run_main(
request_type, url, data, header)
print("返回结果：", response)
res = json.loads(response)
# 获取token、operid并写入文件中
with open(self.util.base_dir(), 'w') as f:
f.write(res["data"]["token"] + "," + res["data"]["id"])
print("获取token：", res["data"]["token"])
else:
token = self.util.getToken(0)
operid = self.util.getToken(1)
token_header = self.data.get_token_header(i, token)
depend_morecase = self.data.is_more_depend(i, 0)
#判断是否存在依赖
if depend_morecase != None:
self.depend_data = DependentData(
depend_morecase, self.sheet_name, self.json_file)
dependent_response_data = self.depend_data.get_data_for_key(
i, 0)
depend_key = self.data.get_dependent_key(i, 0)
print("depend_key", depend_key)
jsonData = json.loads(data)
print("data:", data)
jsonData[depend_key] = dependent_response_data
requestData = json.dumps(jsonData)
response = self.run_method.run_main(
request_type, url, requestData, token_header)
else:
if self.data.get_model(i) == "用户更新":
jsonData = json.loads(data)
jsonData['id'] = operid
requestData = json.dumps(jsonData)
response = self.run_method.run_main(
request_type, url, requestData, token_header)
else:
response = self.run_method.run_main(
request_type, url, data, token_header)
expect_res = self.data.get_except(i)
print("期望结果：", expect_res)
if self.util.is_contain(expect_res, response):
self.data.write_result(i, "测试通过", self.sheet_id)
pass_count.append(i)
print("测试通过")
else:
self.data.write_result(i, "测试失败", self.sheet_id)
fail_count.append(i)
print("测试失败")
self.data.write_response(i, response, self.sheet_id)
#self.email.send_main(pass_count, fail_count)
return response
