class DependentData:
def __init__(self):
self.case_id = case_id
self.operation_excel = OperationExcel()
self.data = GetData()
#通过case-id去获取case的整行数据
def get_case_line_data(self, case_id):
rows_data = self.operation_excel.get_row_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.operation_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, header)
return res
#根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self, row):
depend_data = self.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 DependentData:
"""解决数据依赖问题"""
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
case_value[case_id] = {} #先创建空的字典之后存{caseid：{id1：1}}
def get_case_line_data(self):
"""
通过case_id去获取该case_id的整行数据
:param case_id: 用例ID
:return:
"""
rows_data = self.opera_excel.get_row_data(self.case_id)
return rows_data
def run_dependent(self):
"""
查询依赖caseid的响应数据并返回
:return:
"""
row_num = self.opera_excel.get_row_num(self.case_id)
res = self.data.get_respond_data(row_num)
rj = json.loads(res)
return rj
def get_data_for_key(self, row):
"""
根据依赖的key去获取执行依赖case的响应然后返回
:return:依赖字段+依赖值 [id1:3]
"""
log_key = None
try:
response_data = self.run_dependent()
depend_data = self.data.get_depend_key(row)
log().info('开始解析依赖字段 %s', depend_data)
depend_k_v = str_to_dict(depend_data)
end_key = {}
for key in depend_k_v:
log_key = key
if not re.search(r'\d', key):
key_findvalue(response_data, key)
else:
r = re.compile(r'\d')
str = r.sub('', key)
key_findvalue(response_data, str)
end_key[key] = key_values[depend_k_v[key]]
key_values.clear()
case_value[self.case_id].update(end_key) #{caseid：{id1:1,id2:2}}
log().info('依赖字段解析完成\n%s', case_value)
return case_value
except Exception as e:
log().error('在%s的响应结果中没有找到依赖字段%s', self.case_id, log_key)
return
class DependentData:
"""解决数据依赖问题"""
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
def get_case_line_data(self):
"""
通过case_id去获取该case_id的整行数据
:param case_id: 用例ID
:return:
"""
rows_data = self.opera_excel.get_row_data(self.case_id)
return rows_data
def run_dependent(self):
"""
执行依赖测试，获取结果
:return:
"""
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.case_id)
#获取第三行
print("1.row_num:", row_num)
#直接获取第三行执行结果即可
real_res = self.data.get_real_res(row_num)
print("依赖case的执行结果：", real_res)
return json.loads(real_res)
def get_data_for_key(self, row):
"""
根据依赖的key去获取执行依赖case的响应然后返回
:return:
"""
print(">>>>>>>>>>>>>>>>", row)
depend_data = self.data.get_depend_key(row)
print("2.depend_data:", depend_data)
response_data = self.run_dependent()
print("3.response_data", response_data)
print("$$$$$$$$$$$$$$$:", [
match.value for match in parse(depend_data).find(response_data)
][0])
return [
match.value for match in parse(depend_data).find(response_data)
][0]
class DependdentData:
def __init__(self, id):
self.id = id
self.opera_excel = OperationExcel()
self.data = GetData()
'''
通过case_id去获取该case_id的整行数据
'''
def get_case_line_data(self, id):
rows_data = self.opera_excel.get_row_data(self.id)
return rows_data
# 执行依赖测试获取结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.id)
# request_data = self.data.get_data_for_json(row_num)
request_data = json.dumps(self.data.get_request_data(row_num))
header = self.data.get_is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_url(row_num)
print('row_num:', row_num, 'request_data:', request_data, 'header:',
header, 'method:', method, 'url:', url)
res = run_method.run_main(method, url, request_data, header) # order
return json.loads(res.text)
# 根据依赖的key获取执行依赖case的响应，然后返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row) # depend_data:text
response_data = self.run_dependent(
) # response_data {"code":0,"text":"order"}
# 获取匹配的数据 match.value
json_exe = parse(
depend_data) # text <class 'jsonpath_rw.jsonpath.Fields'>
madle = json_exe.find(response_data) # []
print('madle:', madle)
return [math.value for math in madle][0]
class DependentData:
"""解决数据依赖问题"""
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
def get_case_line_data(self):
"""
通过case_id去获取该case_id的整行数据
:param case_id: 用例ID
:return:
"""
rows_data = self.opera_excel.get_row_data(self.case_id)
return rows_data
def run_dependent(self):
"""
执行依赖测试，获取结果
:return:
"""
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)
return json.loads(res)
def get_data_for_key(self, row):
"""
根据依赖的key去获取执行依赖case的响应然后返回
:return:
"""
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
return [
match.value for match in parse(depend_data).find(response_data)
][0]
class GetData():
def __init__(self, file_path=None, sheet_id=None):
self.oper_excel = OperationExcel()
self.oper_json = OperationJson(
os.path.join(os.getcwd(), 'request_data.json'))
def get_case_id(self, row):
col = int(ExcelCol.get_id())
case_id = self.oper_excel.get_cell_value(row, col)
return case_id
def get_nrows(self):
return self.oper_excel.get_nrows()
def get_is_run(self, row):
flag = None
col = int(ExcelCol.get_is_run())
is_run = self.oper_excel.get_cell_value(row, col)
if is_run == 'yes':
flag = True
else:
flag = False
return flag
def get_url(self, row):
col = int(ExcelCol.get_url())
url = self.oper_excel.get_cell_value(row, col)
return url
def get_request_data(self, row):
col = int(ExcelCol.get_request_data())
json_key = self.oper_excel.get_cell_value(row, col)
json_value = self.oper_json.get_json_value(json_key)
return json_value
def get_request_method(self, row):
col = int(ExcelCol.get_request_method())
request_method = self.oper_excel.get_cell_value(row, col)
return request_method
def get_header(self, row):
col = int(ExcelCol.get_header())
header = self.oper_excel.get_cell_value(row, col)
if header == None:
return None
else:
return header
def get_expect(self, row):
col = int(ExcelCol.get_expect())
expect = self.oper_excel.get_cell_value(row, col)
# expect_db = OperationDB(expect)
return expect
def get_depend_key(self, row):
col = int(ExcelCol.get_field_id())
depend_key = self.oper_excel.get_cell_value(row, col)
return depend_key
def get_field_key(self, row):
col = int(ExcelCol.get_field_data())
field_key = self.oper_excel.get_cell_value(row, col)
return field_key
def get_field_data_id(self, row):
col = int(ExcelCol.get_field_data_id())
field_data_id = self.oper_excel.get_cell_value(row, col)
return field_data_id
def write_res(self, row, res):
col = int(ExcelCol.get_result())
self.oper_excel.write_result(row, col, res)
def get_expect_by_case(self, row):
oper_db = OperationDB(self.get_case_id(row))
expect_db = oper_db.search_one()
return expect_db
# 根据依赖case_id获取到要执行的用例id的行号
def get_depend_line(self, case_id):
num = 0
cols_data = self.get_col_datas()
for col_data in cols_data:
if case_id in col_data:
return num
num += 1
return num
def get_row_values(self, row):
return self.oper_excel.get_row_data(row)
# 获取某一列的内容
def get_col_datas(self, col=None):
col_datas = self.oper_excel.get_col_datas(col)
return col_datas
class DependentData(object):
def __init__(self, case_id):
self.case_id = case_id
self.data = GetData()
self.opera_excel = OperationExcel()
#通过case_id获取case_id的整行数据
def get_case_id_data(self):
rows_data = self.opera_excel.get_row_data(self.case_id)
# print(rows_data)
return rows_data
#执行依赖case，获取依赖返回数据
def run_dependent_case(self):
#获取行号
row = self.opera_excel.get_row_num(self.case_id)
dependent_url = self.data.get_request_url(row)
# print(dependent_url)
dependent_data = self.data.getdata(row)
# print(dependent_data)
dependent_methon = self.data.get_request_way(row)
# print(dependent_methon)
dependent_cookie = self.data.get_cookie(row)
# res = RunMain().run_post(dependent_url,dependent_data)
# method,url,data = None,cookie = None
run_dependent = RunMain()
res = run_dependent.run_main(dependent_methon, dependent_url,
dependent_data, dependent_cookie)
print(res)
return res
#根据依赖的key获取执行依赖测试case，后返回key对应的值
def get_key_for_data(self, row):
#获取key
# data = GetData()
key = self.data.get_dependent_key(row)
response_data = self.run_dependent_case()
res_data = json.loads(response_data)
print(res_data)
json_exe = parse(key)
# print(json_exe)
# madle = json_exe.find(response_data)
# return [match.value for math in madle][0]
return [match.value for match in json_exe.find(res_data)][0]
def test1(self):
jsonpath_expr = parse('ortherData.[0].userNo')
data = {
"code": 200,
"count": 0,
"data": "",
"errorData": "",
"isPage": 0,
"limit": 0,
"msg": "登录成功,已返回用户编号",
"operationType": "",
"ortherData": [{
"userNo": "U-4515151109911622E7"
}],
"ortherMsg": "",
"page": 0,
"totlePage": 0
}
# data1 = json.loads(data)
print([match.value for match in jsonpath_expr.find(data)][0])