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