class DependentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
#通过case_id 去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opara_excel.get_rows_data(self.case_id)
return rows_data
#执行*依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
#找到对应的行号，后续获取其他数据需要用到
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.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)
# 获取这些数据以便后续run_main 方法使用
res = run_method.run_main(method, url, request_data, header)
return json.loads(res)
# 根据依赖的key获取执行依赖case的响应数据，然后返回 ***
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
# 依赖的返回数据一般都是给出来，去运行case里边解析拿到对应的需要的数据
response_data = self.run_dependent()
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
# for i in madle: ???
# i.value
return [math.value for math in madle][0] # ???增强的for 循环
class DependdetData(object):
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
self.run_method = RunMethod()
# 通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
row_data = self.opera_excel.get_rows_data(self.case_id)
return row_data
# 执行依赖case
def run_dependent(self):
row_num = self.opera_excel.get_row_num(
self.case_id) # 先要通过case_id去获取依赖case的行号啊
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
data = self.data.get_data_for_json(row_num)
header = self.data.is_header(row_num)
res = self.run_method.run_main(method, url, data, header,
params=data).json()
# 执行依赖的时候获取响应的json数据,不然我拿不到依赖case的响应,因为我在runmain里面res没有转成json啊，嘿嘿
return res # json字典类型
# 根据依赖的key去获取依赖case的响应，并返回values
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
#print(depend_data)
#print(response_data)
#print(type(response_data))
return [
match.value for match in parse(depend_data).find(response_data)
][0]
class DependData:
def __init__(self, case_id):
self.case_id = case_id
self.oper_excel = OperationExcel()
self.data = GetData()
# 通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.oper_excel.get_row_values(self.case_id)
# 执行所依赖接口，获得结果
def run_dependent(self):
run_method = RunMethod()
rowx = self.oper_excel.get_row_num(self.case_id)
url = self.data.get_url(rowx)
# header = self.data.get_header(rowx)
request_data = self.data.get_request_for_json(rowx)
method = self.data.get_method_type(rowx)
res = run_method.run_main(url, method, request_data)
return res
# 根据excel中“依赖的返回数据”，查找前置接口运行结果的字段
def get_data_for_key(self, rowx):
depend_data = self.data.get_depend_respons(rowx) # excel中依赖的返回字段
response_data = self.run_dependent() # 前置接口运行后的返回结果
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
return [math.value for math in madle] # 返回匹配的字段值
class DependentData(object):
def __init__(self, case_id):
self.case_id = case_id
self.op_excel = OperationExcel()
self.data = GetData()
def get_case_line_data(self):
rows_data = self.op_excel.get_rows_data(self.case_id)
return rows_data
def run_dependent(self):
run_method = RunMethod()
row_num = self.op_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
# header = self.data.get_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_url(row_num)
res = run_method.run_main(method, url, request_data)
return json.loads(res)
def get_data_for_key(self, row):
data_depend = self.data.get_data_depend(row)
response_data = self.run_dependent()
json_exe = parse(data_depend)
madle = json_exe.find(response_data)
return [math.value for math in madle][0]
class DependdentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel(1, 'config/test_case.xls')
self.data = GetData()
# 通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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)
url = self.data.get_request_url(row_num)
res = run_method.run_main(method, url, request_data, {'Content-Type': 'application/x-www-form-urlencoded'})
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应,然后返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
print(response_data)
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.oper_excel = OperationExcel()
self.method = RunMethod()
self.data = GetData()
# 通过case_id去获取依赖case_id的整行数据
def get_case_line_data(self):
rows_data = self.oper_excel.get_rows_data(self.case_id)
return rows_data
# 执行依赖测试，获取结果
def run_dependent(self):
row_num = self.oper_excel.get_row_num(self.case_id)
request_data = self.data.get_data_value(row_num)
header = self.data.get_request_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
res = self.method.run_main(method, url, request_data, header, params=request_data)
return res
# 获取依赖字段的响应数据：通过执行依赖测试case来获取响应数据，响应中某个字段数据作为依赖key的value
def get_value_for_key(self, row):
# 获取依赖的返回数据key
depend_data = self.data.get_depend_key(row)
# 执行依赖case返回结果
response_data = self.run_dependent()
# print(depend_data)
# print(response_data)
return [match.value for match in parse(depend_data).find(response_data)][0]
class DependdentData:
def __init__(self, case_id):
self.opera_excel = OperationExcel()
self.data = GetData()
self.case_id = case_id
#通过case_id 获取case_id 整行数据
def get_case_lines_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependnt(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)
request_method = self.data.get_request_method(row_num)
request_header = self.data.get_data_header_json(row_num)
request_url = self.data.get_request_url(row_num)
res = run_method.run_main(request_method, request_url, request_header,
request_data)
return json.loads(res)
# return res
# 根据依赖的key，去获取 执行依赖case的相应 response，然后返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependnt()
print depend_data
print response_data
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
# aa = [madle.value for math in madle][0]
return [madle.value for math in madle]
class DependdentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
# 通过case-id去获取该case—id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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)
url = self.data.get_request_url(row_num)
header = self.data.is_header(row_num)
method = self.data.get_request_method(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.data.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 DependdentData:
def __init__(self, sheet_id, case_id):
self.case_id = case_id
self.sheet_id = sheet_id
self.opera_excel = OperationExcel(self.sheet_id)
self.data = GetData(self.sheet_id)
#根据case_id去获取该case的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖的case，得到接口返回结果
def run_dependent(self):
run_method = RunMethod()
#获取依赖case的行号
row_num = self.opera_excel.get_row_num(self.case_id)
#获取依赖case的请求数据
request_data = self.data.get_request_data(row_num)
header = self.data.is_header(row_num)
headers =\
{
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
"Content-Type": "application/json;charset=UTF-8"
}
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, headers)
return res
#根据依赖的key获取key的value
def get_data_for_key(self, depend_data):
#获取依赖的请求数据
json_expr = parse(depend_data)
#获取依赖case的行号
row_num = self.opera_excel.get_row_num(self.case_id)
#获取依赖case的接口返回结果
response_data1 = self.data.get_result_res(row_num)
response_data = eval(response_data1)
print(depend_data)
depend_data = eval(str(depend_data))
return depend_data
class DependentData:
def __init__(self, case_id):
self.case_id = case_id
self.oper_excel = OperationExcel()
self.method = RunMethod()
self.data = GetData()
# 通过case_id去获取依赖case_id的整行数据
def get_case_line_data(self):
rows_data = self.oper_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependent(self):
row_num = self.oper_excel.get_row_num(self.case_id)
request_data = self.data.get_data_value(row_num)
header = self.data.get_request_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
if (header == 'write_Cookies'):
header = {
'Content-Type': 'application/json',
"X-Lemonban-Media-Type": "lemonban.v2"
}
data = json.dumps(request_data)
res = self.method.run_main(method, url, data, header, params=data)
else:
res = self.method.run_main(method,
url,
request_data,
header,
params=request_data)
return res
#获取依赖字段的响应数据：通过执行依赖测试case来获取响应数据，响应中某个字段数据作为依赖key的value
def get_value_for_key(self, row):
newdepend = ''
#获取依赖的返回数据key
depend_data = self.data.get_depend_key(row)
#执行依赖case返回结果
response_data = self.run_dependent()
if ',' in depend_data:
newdepend_data = depend_data.split(',')
if len(newdepend_data) > 1:
for index, item in enumerate(newdepend_data):
newdepend += str([
match.value
for match in parse(item).find(response_data)
][0]) + ","
return newdepend
else:
return [
match.value for match in parse(depend_data).find(response_data)
][0]
class DependentDataJson:
def __init__(self, excel_prop):
self.excel_prop = excel_prop
self.opera_excel = OperationExcel()
xiao_iron = 'E:/xt/xironbardepend/xironbackend/'
self.data = GetData(xiao_iron + 'dataconfig/interfacebar1.xlsx', 6)
self.read_ini = ReadIni()
# 组装执行请求需要的数据，组装 excel_prop
def assemble_excel_prop(self):
case_depend_list = json.loads(self.excel_prop.case_depend)
for case_depend in case_depend_list:
case_depend_obj = CommonUtil.dict_to_object(case_depend)
case_dp_value = self.get_pre_data_for_case_and_key(case_depend_obj.dp_case_id, case_depend_obj.dp_key)
if case_depend_obj.fit_field is not None:
if 'data_type' in case_depend_obj.keys() and case_depend_obj.data_type == 'list':
fit_field_value_list = list()
fit_field_value_list.append(case_dp_value)
self.excel_prop.request_data[case_depend_obj.fit_field] = fit_field_value_list
else:
self.excel_prop.request_data[case_depend_obj.fit_field] = case_dp_value
else:
# 填充数据为空的时候，需要直接填充到 url 上
self.excel_prop.url = self.excel_prop.url.replace('{' + case_depend_obj.dp_key + '}', case_dp_value)
return self.excel_prop
# 通过 case_id dp_key,获取前置数据中 dp_key对应的值
def get_pre_data_for_case_and_key(self, case_id, dp_key):
row_num = self.opera_excel.get_row_num(case_id)
pre_data = json.loads(self.data.get_pre_data(row_num)) # pre_data 是直接从 excel中读取，不用通过 json的 key获取
return self.dict_get(pre_data, dp_key, None)
# 获取字典中的objkey对应的值，适用于字典嵌套
# dict:字典 objkey:目标key default:找不到时返回的默认值
def dict_get(self, _dict, key, default):
tmp = _dict
for k, v in tmp.items():
if k == key:
return v
else:
if isinstance(v, list):
for item in v:
ret = self.dict_get(item, key, default)
if ret is not default:
return ret
elif isinstance(v, dict):
ret = self.dict_get(v, key, default)
if ret is not default:
return ret
return default
class DependdentData:
def __init__(self, case_id, fileName, sheetid):
self.case_id = case_id
self.opera_excel = OperationExcel(file_name=fileName, sheet_id=sheetid)
self.data = GetData(fileName=fileName, sheetid=sheetid)
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.case_id)
print("row_num====", row_num)
url = self.data.get_request_domain(
row_num) + self.data.get_request_path(row_num)
method = self.data.get_request_method(row_num)
header = self.data.get_request_header(row_num)
# request_data = self.data.get_data_for_json(row_num)
params = self.data.get_requestParams(row_num)
body = self.data.get_body(row_num)
cookies_1 = self.data.get_cookies(row_num)
res = run_method.run_main(url,
method,
cookies=cookies_1,
body=body,
headers=header,
params=params)
return json.loads(res.text)
#根据依赖的key去获取执行依赖测试case的响应,然后返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
print("depend_data===", depend_data)
response_data = self.run_dependent()
print("response_data===", response_data)
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
list = [math.value for math in madle]
print("list===", list)
return list[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)
#获取第三行
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 DependentData:
def __init__(self, case_id, sheet_name, json_file):
self.oper_excel = OperationExcel(sheet_name)
self.util = CommonUtil()
self.case_id = case_id
self.data = GetData(json_file, sheet_name)
# 通过case_id获取case_id的整行数据
def get_case_line_data(self):
rows_data = self.oper_excel.get_rows_data(self.case_id)
return rows_data
# 执行依赖测试，获取返回结果
def run_dependent(self):
run_method = RunMethod()
row_num = self.oper_excel.get_row_num(self.case_id)
# print("row_num:", row_num)
row_data = self.get_case_line_data()
# print("row_data:", row_data)
request_data = self.data.get_data_for_json(row_num)
# print("request_data:", request_data)
url = self.data.get_url(row_num)
# print("url:", url)
method = self.data.get_request_type(row_num)
# print("method:", method)
token_header = self.data.get_token_header(row_num,
self.util.getToken(0))
# print("依赖的token_header:", token_header)
res = run_method.run_main(method, url, request_data, token_header)
# print("res:", res)
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应，然后返回对应的返回值
def get_data_for_key(self, row, index):
dependent_data = self.data.get_dependent_data(row, index)
# print("dependent_data:", type(dependent_data))
# print("dependent_data:", dependent_data)
response_data = self.run_dependent()
# print("response_data:", type(response_data))
# print("response_data:", response_data)
json_exe = parse(dependent_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()
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 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 DependsData:
def __init__(self,caseid):
self.data=GetData()
self.excel=OperationExcel()
self.caseid=caseid
def run_depend_case(self):
resquet=MyRequests()
i=self.excel.get_row_num(self.caseid)
url=self.data.get_url(i)
data=self.data.get_request_data(i)
method=self.data.get_methon(i)
header=self.data.get_header(i)
res=resquet.run_main(url,method,data,header)
return json.loads(res)
#╗ы╚Аих╗пох
def get_data_for_key(self,row):
depend_data=self.data.get_depends_key(row)
response_data=self.run_depend_case()
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_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
# 执行依赖测试，获取结果
def run_dependent(self):
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 = self.run_method.run_main(method,url,request_data,header)
# print("there are res's data",res)
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self,row):
depend_data = self.data.get_depend_key(row)
print("this is dependData =",depend_data)
# 获取执行依赖case执行的返回结果并赋值给response_data
response_data = self.run_dependent()
print("this is responsedata = ",response_data)
jsonpath_exe = parse(depend_data)
# print("this json_exe=",jsonpath_exe)
print(parse("data.shopGoodsList[*].rderNum").find(response_data))
madle = jsonpath_exe.find(response_data)
print("this is madle = ",madle)
print( [match.value for match in madle][0])
return [match.value for match in madle][0]
class DependentData:
def __init__(self,case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data =GetData()
# 根据依赖caseid去获取该caseid整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
# 执行依赖测试，获取结果
def run_dependent(self):
run_method = RunMethod()
# 拿到行号，获取get_data等需要行号获取
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)
# if header == 'yes':
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
return json.loads(res)
# 根据依赖的key去获取执行依赖测试case的响应，然后返回
def get_data_for_key(self,row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
# print("------------->>>>>>")
# print(depend_data)
# print(response_data)
# 响应值为字符串，需要处理。根据层级关系去拿
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
# for i in madle: i是字段类型
# i.value
# course:[0]:out_trade_no
return [math.value for math in madle][0]
class DependData:
def __init__(self, case_id):
self.casi_id = case_id
self.operation = OperationExcel()
self.data = GetData()
# 根据caseid获取行的内容
def get_lines_data(self):
self.operation.get_rows_data(self.casi_id)
# 执行依赖测试case，获取结果
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)
# 获取依赖case的值
def get_depned_value(self, row):
depend_data = self.data.get_depend_data(row) # 获取匹配的依赖字段
response_data = self.run_depend_case() # 获取响应数据
json_exe = parse(depend_data) # 根据depend_data去匹配对应的值
madel = json_exe.find(response_data) # 查找
return [math.value for math in madel] # 返回找到的值
class DependdentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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)
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)
#根据依赖的key去获取执行依赖测试case的响应,然后返回
def get_data_for_key(self, row):
depend_data = self.data.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.run_method = RunMethod()
self.data = GetData()
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_data
#执行依赖测试,获取结果
def run_dependent(self):
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
header = self.data.get_header_for_json(row_num)
url = self.data.get_url(row_num)
method = self.data.get_requst_method(row_num)
# print(row_num, request_data, header, url, method)
res = self.run_method.run_main(method, url, request_data, header[0])
return json.loads(res)
#根据依赖的key去获取依赖测试case的请求值且返回
def get_data_for_key(self, row):
depend_data = self.data.get_depend_key(row)
#打印正则
# print(depend_data)
response_data = self.run_dependent()
json_exe = parse(depend_data)
madle = json_exe.find(response_data)
#打印通过正则而得到的结果
# print(madle)
return [math.value for math in madle][0]
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])
class DependentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
xiao_iron = 'E:/xt/xironbardepend/xironbackend/'
self.data = GetData(xiao_iron + 'dataconfig/interfacebar1.xlsx', 2)
self.read_ini = ReadIni()
# 通过 caseid 去获取该 caseID 的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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.get_header(row_num)
method = self.data.get_request_method(row_num)
url = self.read_ini.get_value() + self.data.get_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.data.get_depend_key(row)
is_pre_start = depend_data.startswith('pre:')
if is_pre_start:
depend_key = depend_data.split(':')[1]
return self.get_pre_data(depend_key)
else:
response_data = self.run_dependent()
res = self.dict_get(response_data, depend_data, None)
return res
def get_pre_data(self, depend_key):
row_num = self.opera_excel.get_row_num(self.case_id)
pre_data = json.loads(self.data.get_pre_data(
row_num)) # pre_data 是直接从 excel中读取，不用通过 json的 key获取
res = pre_data[depend_key]
return res
# 获取字典中的objkey对应的值，适用于字典嵌套
# dict:字典 objkey:目标key default:找不到时返回的默认值
def dict_get(self, _dict, key, default):
tmp = _dict
for k, v in tmp.items():
if k == key:
return v
else:
if isinstance(v, list):
for item in v:
ret = self.dict_get(item, key, default)
if ret is not default:
return ret
elif isinstance(v, dict):
ret = self.dict_get(v, key, default)
if ret is not default:
return ret
return default
class DependdentData:
def __init__(self,case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
#通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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)
#根据依赖的key去获取执行依赖测试case的响应,然后返回
def get_data_for_key(self,row):
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
res_value = self.get_parse_field_value(depend_data,response_data)
return res_value
# json_exe = parse(depend_data)
# madle = json_exe.find(response_data)
# print("madle is %s" %madle)
# return [math.value for math in madle][0]
#根据依赖的key获取用例中响应结果
def get_data_for_excel(self,row):
depend_data = self.data.get_depend_key(row)
row_num = self.opera_excel.get_row_num(self.case_id)
response_data = self.data.get_response_result_field(row_num)
# json_exe = parse(depend_data)
# madle = json_exe.find(response_data)
# return [math.value for math in madle][0]
part_value = self.get_parse_field_value(depend_data,response_data)
return part_value
#通过解析依赖的返回数据字段中内容，返回前一次解析结果中的值
def get_parse_field_value(self,depend_data,response_data):
json_exe = parse(depend_data)
# print("response data is %s " %response_data)
m = json.loads(response_data)
madle = json_exe.find(json.loads(response_data))
return [math.value for math in madle][0]
class DependdentData:
def __init__(self, case_id):
self.case_id = case_id
self.opera_excel = OperationExcel()
self.data = GetData()
# 通过case_id去获取该case_id的整行数据
def get_case_line_data(self):
rows_data = self.opera_excel.get_rows_data(self.case_id)
return rows_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)
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)
# 根据依赖的key去获取执行依赖测试case的响应,然后返回
def get_data_for_key(self, row):
# 定义一个空数组,用来返回依赖case对应的响应结果
denpent_key_result = []
depend_data = self.data.get_depend_key(row)
response_data = self.run_dependent()
# print("response_data=======%s" % response_data)
# 把依赖数据根据"，"切割成数组遍历
depend_data_list = depend_data.split(",")
for data in depend_data_list:
json_exe = parse(data)
madle = json_exe.find(response_data)
# 得到依赖key对应的值
denpent_key = [math.value for math in madle][0]
# 将依赖key对应的结果依次放入结果集里
denpent_key_result.append(denpent_key)
# 返回依赖key对应的结果
return denpent_key_result
