def __init__(self):
self.run_method = RunMethod()
self.get_data = Get_Data()
self.compare = Is_Contain()
self.save_res = Save_Resp()
# self.depend_data = Dependent_Data()
self.resp_data = {}
class DependdentData():
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = Operation_Excel()
self.data = Get_Data()
def get_case_line_data(self):
rows_data = self.opera_excel.get_row_data(self.case_id)
return rows_data
def run_dependdent(self):
run_method = Run_Request()
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.read_data_for_json(row_num)
# header = self.data.is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_url(row_num)
res = run_method.run_type(method, url, request_data)
return json.loads(res)
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependdent()
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
return [math.value for math in madle]
def __init__(self):
self.data=Get_Data()
self.run_request=Run_Request()
self.com_util = CommonUtil()
self.send_email=Send_Email()
self.user_log=User_Log()
self.open_logging=self.user_log.get_log()
class Run_Main():
def __init__(self):
self.data=Get_Data()
self.run_request=Run_Request()
self.com_util = CommonUtil()
self.send_email=Send_Email()
self.user_log=User_Log()
self.open_logging=self.user_log.get_log()
def go_on_run(self):
error_num=1
passlist=[]
faillist=[]
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 == True:
while error_num <= Config_Try_Num:
url = self.data.get_url(i)
method = self.data.get_request_method(i)
data = self.data.read_data_for_json(i)
expect = self.data.get_expect_data(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)
depend_key = self.data.get_depend_field(i)
data[depend_key] = depend_response_data
res = self.run_request.run_type(method, url, data)
class Dependent_Data(object):
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = Operation_Excel()
self.get_data = Get_Data()
self.log = Log()
self.row_index = self.opera_excel.get_index_caseId(self.case_id)
# 根据传入的case_id 获取该行数据
def get_case_line_data(self):
row_data = self.opera_excel.get_rowData_caseId(self.case_id)
return row_data
# 执行依赖数据, 获取结果
def run_method(self):
run_method = RunMethod()
request_data = self.get_data.get_data_for_json(self.row_index)
method = self.get_data.get_request_method(self.row_index)
url = self.get_data.get_url(self.row_index)
header = self.get_data.is_header(self.row_index)
res = run_method.run_main(method, url, request_data, header)
logger.info(f"request_data is {request_data}, index is {self.row_index}, resp is {res}")
return res
# 根据依赖的key去获取执行依赖测试case的响应，然后返回对应的值
def get_resp_caseResult(self, data, row):
# 得到该case的依赖表达式
depend_expr = self.get_data.get_depend_expr(row)
logger.info(f"expr === {depend_expr}, type === {type(depend_expr)}")
# 查询到依赖数据所依赖的字段
data_key = self.get_data.get_depend_dataName(row)
logger.info(f"expr_data_key is {data_key}")
# 根据依赖表达式获取响应的结果
# data_value = jsonpath.jsonpath(json.loads(self.run_method()), depend_expr)[0]
data_value = Save_Resp.expr_data(data, depend_expr)
logger.info(f"expr_data_value is {data_value}")
return data_key, data_value
#
def test_1(self):
depend_expr = self.get_data.get_depend_expr(2)
res = '{"mobile":"18844077709"}'
data_key = self.get_data.get_depend_dataName(2)
data_value = jsonpath.jsonpath(json.loads(res), depend_expr)[0]
return data_value
from utils.driverUtil import DriverUtil
# driver = None
@pytest.fixture(scope="session", autouse=True)
def driver():
"""所有用例执行前、后执行"""
log.create_log()
# driver = DriverUtil.get_web_driver(wait=0)
driver = DriverUtil.get_app_driver()
yield driver
DriverUtil.quit_driver()
@pytest.fixture(scope="class")
def login_class(driver):
"""登陆测试_类"""
driver.get("http://ttmp.research.itcast.cn/#/login")
@pytest.fixture(scope="function", params=Get_Data.get_data_json("login.json", direction=0))
def login(request):
"""登陆测试_方法"""
yield request.param
@pytest.fixture(scope="function", params=Get_Data.get_data_json("app_login.json", direction=1))
def app_login(request):
"""登陆测试_方法"""
yield request.param
def __init__(self):
self.run_method = Request_method()
self.getData = Get_Data()
self.compare = Compare()
class RunTest():
def __init__(self):
self.run_method = Request_method()
self.getData = Get_Data()
self.compare = Compare()
#执行程序
def run_test(self,filename):
case_count = self.getData.get_excel_lines()
for i in range(1,case_count):
url = self.getData.get_request_url(i)
method = self.getData.get_method(i)
data = self.getData.get_data_for_json(filename)
header = json.loads(self.getData.get_header(i))
is_run = self.getData.if_is_run(i)
exp_restult = self.getData.get_exp_result(i)
if is_run == True:
res = self.run_method.run_requests(method,url,data,header)
if self.compare.is_contain(exp_restult,res):
#print("测试通过")
self.getData.write_exl_result(i,u"测试通过")
else:
#print("测试失败")
self.getData.write_exl_result(i,u"测试失败")
return res
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = Operation_Excel()
self.data = Get_Data()
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = Operation_Excel()
self.get_data = Get_Data()
self.log = Log()
self.row_index = self.opera_excel.get_index_caseId(self.case_id)
class RunTest:
def __init__(self):
self.run_method = RunMethod()
self.get_data = Get_Data()
self.compare = Is_Contain()
self.save_res = Save_Resp()
# self.depend_data = Dependent_Data()
self.resp_data = {}
# 程序执行
def go_on_run(self):
header = None
res = None
pass_count = []
fail_count = []
rows_counts = self.get_data.get_lines()
for i in range(1, rows_counts):
is_run = self.get_data.is_Run(i)
method = self.get_data.get_request_method(i)
url = self.get_data.get_url(i)
data = self.get_data.get_data_for_json(i)
logger.info(f"request_data is {data}, type ====> {type(data)}")
expect_data = self.get_data.get_except_data(i)
header = self.get_data.is_header(i)
# 判断该条case是否有依赖数据
depend_id = self.get_data.get_depend_caseId(i)
if depend_id:
depend_data = Dependent_Data(depend_id)
# 根据依赖表达式，获取依赖的数据以及依赖的字段
depend_key, depend_value = depend_data.get_resp_caseResult(
self.resp_data, i)
logger.info(f"depend_value =====> {depend_value}")
data[depend_key] = depend_value
# 更新请求数据
logger.info(
f"request_data_2 is {data}, type ====> {type(data)}")
# method, url, data, header
if is_run:
res = self.run_method.run_main(method, url, data, header)
logger.info(f"res is type {type(res)}")
# if ("token" in res):
# Get_Token.get_header(res['token'])
self.save_res.save_opt(self.resp_data, self.get_data.get_id(i),
json.loads(res))
compare_result = self.compare.is_contain(expect_data, res)
if compare_result:
self.get_data.write_result(i, "pass")
pass_count.append(i)
else:
self.get_data.write_result(i, res)
fail_count.append(i)
logger.info(f"data is {self.resp_data}")