def go_on_run(self): res = None pass_conut = [] fail_conut = [] rows_conut = self.data.get_case_lines() for i in range(1, rows_conut): is_run = self.data.get_is_run(i) if is_run: self.request_type = self.data.get_request_type(i) url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_json_data(i) case_name = self.data.get_case_name(i) cookie = self.data.get_cookies_value(i) expect = self.data.get_expect_data(i) depent_case = self.data.case_id(i) # 获取依赖字段的key if depent_case is not None: # 获取依赖的key depent_key = self.data.get_depnet_file(i) self.depend_data = DepnedentData(depent_case) # 获取依赖的响应数据 depnet_response_data = self.depend_data.get_data_for_key(i) le = len(depent_key.split(">")) # 切分字符串取大小 for y in range(0, le): re = depent_key.split(">") request_data[re[y]] = depnet_response_data[y] # 循环替换 if cookie == 'write': # 发送请求 res = self.run_method.run_main(method, url, request_data) op_cookies = OperationHeader(res) op_cookies.write_cookie() # 写入cookies到cookie.json文件中 elif cookie == 'yes': get_cookie = OperationJson('../dataconfig/cookie.json') cooki = get_cookie.get_data('SESSION') cookies = { "SESSION": cooki } res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) if self.containt.is_contain(expect, res): self.data.write_result(i, 'pass') pass_conut.append(i) self.logger.info("测试通过") self.logger.info("通过响应数据" + res) print("测试通过") else: self.logger.info("测试失败") self.logger.info("失败case名称:" + case_name) self.logger.info("失败的行数:" + str(i)) self.data.write_result(i, res) fail_conut.append(i) print("测试失败") self.logger.info("url:" + url) self.logger.info("失败请求数据:" + str(request_data)) self.logger.info("失败响应数据:" + res) # 发送测试报告邮件 self.email.send_main(pass_conut, fail_conut)
def go_on_run(self): res = None pass_count = [] fail_count = [] rowcount = self.data.get_case_rowCount() for i in range(1, rowcount): is_run = self.data.get_is_run(i) if is_run: modname = self.data.get_module(i) url = self.data.get_url(i) method = self.data.get_request_method(i) data = self.data.get_data_for_json(i) is_cookie = self.data.get_cookies(i) header = self.data.is_header(i) hoperesult = self.data.get_hopereval(i) is_depend = self.data.is_depend(i) # 是否需要依赖 if is_depend != None: self.depend_data = DependData(is_depend) # 获取依赖的响应数据 depend_response_data = self.depend_data.get_data_for_key(i) # 获取依赖的key depend_key = self.data.get_depend_field(i) data[depend_key] = depend_response_data # 是否保存cookies if is_cookie == 'write': res = self.run_method.run_main(method, url, data) op_headers = OperationHeader(res) if modname == "登录": op_headers.write_login_cookie() else: op_headers.write_cookie() elif is_cookie == 'yes': op_json = OperationJson('../case/cookie.json') header = {"Cookie": op_json.data} res = self.run_method.run_main(method, url, data, header) else: res = self.run_method.run_main(method, url, data) res = res.content.decode('utf-8') # print(res) if self.commonUtil.is_contain(hoperesult, res): self.data.write_realresult(i, res) self.data.write_result(i, "测试成功") pass_count.append(i) else: self.data.write_realresult(i, res) self.data.write_result(i, "测试失败") fail_count.append(i) res = json.loads(res) if (res['statusCode'] != "200"): # print(res['errorMsg']) pass
class RunTest: def __init__(self, file_name=None, sheet_id=0): self.data = GetData(file_name, sheet_id) self.oper_header = OperationHeader() self.run = RunMethod() self.comm = Common() self.send_mail = SendEmail() def go_on_run(self): lines = self.data.get_case_lines() pass_count = [] fail_count = [] for i in range(1, lines): is_run = self.data.get_is_run(i) if is_run: res = None url = self.data.get_url(i) method = self.data.get_method_type(i) fix_request_key = self.data.get_fix_request_key(i) request_data = self.data.get_request_for_json(i) expected = self.data.get_expected_result(i) header = self.data.get_header(i) is_depend = self.data.is_depend(i) if is_depend is not None: depend_case_id = self.data.get_depend_case_id(i) depend_request = self.data.get_depend_request(i) depend_data = DependData(depend_case_id) depend_response = depend_data.get_data_for_key(i) # 从依赖接口的返回结果中匹配需要的依赖字段 request_data[depend_request] = depend_response if header == 'yes': self.oper_header.write_cookie() cookies = self.oper_header.get_cookie() header = {'Cookie': cookies} # json.dump() res = self.run.run_main(url, method, request_data, header) else: res = self.run.run_main(url, method, request_data) # if self.comm.contrast(expected, res): # print("测试通过") # self.data.write_result(i, 'pass') # pass_count.append(i) # else: # print("测试失败") # self.data.write_result(i, res) # fail_count.append(i) # self.send_mail.send_main(pass_count,fail_count) def run_request_data(self, index, value): request_data = self.data.get_request_for_json(index) key = self.data.get_fix_request_key(index) request_data[key] = value return request_data def run_expected_data(self, index, value): key = self.data.get_expected_result(index) expected_data = {} expected_data[key] = value expected_data = key + ":" + expected_data[key] return expected_data
def go_on_run(self): # 10 0,1,2,3, res = None pass_count = [] fail_count = [] rows_count = self.data.get_case_lines() print(rows_count) for i in range(1, rows_count): is_run = self.data.get_is_run(i) if is_run: url = self.data.get_request_url(i) print(i, url) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) expect = self.data.get_expect_data(i) header = self.data.is_header(i) depend_case = self.data.is_depend(i) # res = self.run_method.run_main(method, url, data, header) # if is_run: # method,url,data=None,header=None if depend_case != None: # self.depend_data = DependentData(depend_case) print("depend_case is" + " --- " + depend_case) self.depend_data = DependentData(depend_case) # 获取的依赖响应数据 depend_response_data = self.depend_data.get_data_for_key(i) # 获取依赖的key print(depend_response_data) depend_key = self.data.get_depend_field(i) print(depend_key) request_data[depend_key] = depend_response_data if header == "write": res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperationJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} # cookie = op_header.get_data() # cookie = ../dataconfig/cookie.json ../dataconfig/cookie.json res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) # res = self.run_method.run_main(method,url,request_data,header) # print(res) if self.com_util.is_contain(expect, res): # print("测试通过") self.data.write_result(i, 'pass') pass_count.append(i) else: # print("测试失败") # self.data.write_result(i, 'fail') self.data.write_result(i, res) fail_count.append(i) self.send_email.send_main(pass_count, fail_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] #10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) #通过数据库获取预期结果 #expect = self.data.get_expcet_data_for_mysql(i) expect = self.data.get_expcet_data(i) header = self.data.is_header(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) #获取依赖的key depend_key = self.data.get_depend_field(i) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) print(res) print(type(res)) #if self.com_util.is_equal_dict(expect,res) == 0: #if self.com_util.is_contains_dict(expect,res): if self.com_util.is_contain(expect, res): self.data.write_result(i, 'pass') pass_count.append(i) res = pass_count else: #self.data.write_result(i,res) self.data.write_result(i, 'fail') fail_count.append(i) res = fail_count
def go_on_run(self): # 程序执行 pass_count = [] fail_count = [] 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) data = self.data.get_data_for_json(i) # expect = self.data.get_expect_data(i) # Excel写入预期结果 expect = self.data.get_expect_data_for_mysql(i) header = self.data.is_header(i) depend_case = self.data.is_depend(i) res = self.run_method.run_main(method, url, data, header) values = {"resultCode": res["resultCode"]} # print(res["resultData"]["access_id"]) value = json.dumps(values) # 字典转字符串匹配 if depend_case is not None: self.depend_data = DependentDate(depend_case) # 依赖响应数据 depend_response_data = self.depend_data.get_data_for_key(i) # 获取依赖的key data = json.loads(data) depend_key = self.data.get_depend_field(i) data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperationJson('../dataconfig/cooking.json') cookie = op_json.get_data('apsid') cookies = { 'apsid': cookie } value = self.run_method.run_main(method, url, data, cookies) else: value = self.run_method.run_main(method, url, data) if self.commonutil.is_equal_dict(expect, value): self.data.write_result(i, '通过') pass_count.append(i) print('测试通过') else: self.data.write_result(i, '失败') fail_count.append(i) print('测试失败') print(pass_count, fail_count) self.sendmail.send_main(pass_count, fail_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] # 10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) expect = self.data.get_expcet_data(i) header = self.data.is_header(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) # 获取依赖的key depend_key = self.data.get_depend_field(i) #print(request_data) #request_data[depend_key] = depend_response_data request_data = self.operation.deal_data(request_data, depend_key, depend_response_data) if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('config/cookie.json') cookie = op_json.get_data('apsid') cookies = { 'apsid': cookie } res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data, {'Content-Type': 'application/x-www-form-urlencoded'}) if self.com_util.is_equal_dict(expect, res): self.data.write_result(i, 'pass') pass_count.append(i) else: self.data.write_result(i, res) fail_count.append(i) self.send_mai.send_email(pass_count, fail_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] #10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) expect = self.data.get_expcet_data(i) header = self.data.is_header(i) depend_case = self.data.is_depend(i) case_name = self.data.get_case_name(i) if depend_case != None: self.depend_data = DependdentData(depend_case) #获取的依赖响应数据 depend_response_data = self.depend_data.get_data_for_key(i) #获取依赖的key depend_key = self.data.get_depend_field(i) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('./dataconfig/cookie.json') cookie = op_json.get_data('apsid') # cookies = { # 'apsid':cookie # } res = self.run_method.run_main(method, url, request_data, cookie) self.logger.info("用例名称:" + case_name + "--->返回值:" + res) #print(res) else: res = self.run_method.run_main(method, url, request_data) self.logger.info("用例名称:" + case_name + "--->返回值:" + res) #print(res) if self.com_util.is_contain(expect, res) == True: self.data.write_result(i, 'pass') pass_count.append(i) else: self.data.write_result(i, res) fail_count.append(i) #self.send_mai.send_main(pass_count,fail_count) #不带文件发送 self.send_email.sendemail(pass_count, fail_count) #带文件发送
def go_on_run(self): res = None pass_count = [] fail_count = [] #10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) # expect = self.data.get_expcet_data_for_mysql(i) expect = self.data.get_expcet_data(i) # sql_data = expect.strip("[]") sql_data1 = eval(expect) # sql_result = eval(sql_data1) header = self.data.is_header(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) #获取依赖的key depend_key = self.data.get_depend_field(i) request_data[depend_key] = depend_response_data # print(request_data[depend_key]) # res = self.run_method.run_main(method,url,request_data) if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': res = self.run_method.run_main(method, url, request_data) # print(5,res) else: res = self.run_method.run_main(method, url, request_data) print(4, res) if self.com_util.is_equal_dict(res, sql_data1): self.data.write_result(i, 'pass') pass_count.append(i) else: self.data.write_result(i, str(res)) fail_count.append(i) #将运行结果通过钉钉发送 dd_mes(pass_count, fail_count) exit()
def go_on_run(self): res = None pass_count = [] fail_count = [] #10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) # expect = self.data.get_expcet_data_for_mysql(i) expect = self.data.get_expcet_data(i) header = self.data.is_header(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) #获取依赖的key depend_key = self.data.get_depend_field(i) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) # print(res["data"][2]["context"]) print(res) # print(type(res)) #自己写的:这个是判断字段是否在结果中 if expect in res: self.data.write_result(i, "pass") pass_count.append(i) else: self.data.write_result(i, "fail") fail_count.append(i)
def run(self): res = None pass_count = [] fail_count = [] rows_count = self.data.get_case_lines() for i in range(1, rows_count): run = self.data.get_run(i) if run: url = self.data.get_url(i) request_method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) expect = self.data.get_expect(i) print(expect) header = self.data.get_header(i) # case_depend = self.data.get_case_depend(i) # if case_depend != None: # self.depend_data = DependentData(case_depend) # depend_response_data = self.depend_data.get_data_for_key(i) # depend_key = self.data.get_depend_response_data(i) # request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(request_method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperationJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} res = self.run_method.run_main(request_method, url, request_data, cookies) else: res = self.run_method.run_main(request_method, url, request_data) print(res) if self.common_util.is_contain(expect, res) == 1: self.data.write_result(i, 'pass') pass_count.append(i) print(pass_count) else: self.data.write_result(i, res) fail_count.append(i) print(fail_count) self.send_email.send_main(pass_count, fail_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] # 10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) expect = self.data.get_expcet_data_for_mysql(i) header = self.data.is_header(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) # 获取依赖的key depend_key = self.data.get_depend_field(i) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = { 'apsid': cookie } res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) if self.com_util.is_equal_dict(expect, res) == 0: self.data.write_result(i, 'pass') pass_count.append(i) else: self.data.write_result(i, res) fail_count.append(i) self.send_mai.send_main(pass_count, fail_count)
def test_main(self, sheet_name, case_name, sheet_id, case_id): self.data = GetData(sheet_id) is_run = self.data.get_is_run(case_id) if is_run: url = self.data.get_request_url(case_id) method = self.data.get_request_method(case_id) #request_data = self.data.get_data_for_json(i) request_data = self.data.get_request_data(case_id) # expect = self.data.get_expcet_data_for_mysql(i) expect = self.data.get_expcet_data(case_id) header = self.data.is_header(case_id) depend_case = self.data.is_depend(case_id) if depend_case != None: self.depend_data = DependdentData(sheet_id, depend_case) # 获取的依赖响应数据 depend_response_data = self.depend_data.get_data_for_key(case_id) # 获取依赖的key depend_key = self.data.get_depend_field(case_id) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif header == 'yes': op_json = OperetionJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = { 'apsid': cookie } res = self.run_method.run_main(method, url, request_data, cookies) else: res = self.run_method.run_main(method, url, request_data) print(res) if self.com_util.is_contain(expect, res): self.data.write_result(case_id,'pass') else: self.data.write_result(case_id, res) #self.assertIn(expect,res,"预期结果:{0} 未在实际返回结果:{1} 中! ".format(expect,res)) #添加最后结果时间戳 self.data.write_result(0, '实际结果 {}'.format(time.strftime("%Y_%m_%d_%H_%M_%S"))) self.assertIn(expect,res)
def go_on_run(self): res = None pass_count = [] fail_count = [] no_run_count = [] rows_count = self.data.get_case_lines() #每次执行时清楚log文件 log_file = '../log/log.txt' with open(log_file, 'w') as f: f.seek(0, 0) #定位光标位置 f.truncate() #删除文件 for i in range(1, rows_count): try: is_run = self.data.get_is_run(i) if is_run: url = self.data.get_request_url(i) method = self.data.get_request_method(i) #获取请求参数 data = self.data.get_data_value(i) #获取excel文件的关键字 header_key = self.data.get_request_header(i) #获取json文件中header对应的文件数据 header = self.data.get_header_value(i) expect = self.data.get_expect_data(i) depend_case = self.data.is_depend(i) if depend_case != None: self.depend_data = DependentData(depend_case) #获取依赖字段的响应数据 depend_response_data = self.depend_data.get_value_for_key( i) #获取请求依赖的key depend_key = self.data.get_depend_field(i) #将依赖case的响应返回某个字段value赋值给接口请求 data[depend_key] = depend_response_data if header_key == 'write_Cookies': res = self.run_method.run_main(method, url, data, header, params=data) op_header = OperationHeader(res) op_header.write_cookie() elif header_key == 'get_Cookies': op_json = OperationJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} res = self.run_method.run_main(method, url, data, header=cookies, params=data) else: res = self.run_method.run_main(method, url, data, header, params=data) #get请求参数是params:request.get(url='',params={}),post请求数据是data:request.post(url='',data={}) #excel文件中没有区分直接用请求数据表示,则data = self.data.get_data_value(i)拿到的数据,post请求就是data=data,get请就是params=data #excel拿到的expect数据时str类型,返回的是res是dic类型 if self.com_util.is_contain(expect, json.dumps(res)): self.data.write_result(i, 'pass') pass_count.append(i) else: #返回res是dic类型,res数据写入excel中,需要dict转换为str self.data.write_result(i, json.dumps(res)) with open(log_file, 'a', encoding='utf-8') as f: f.write('\n第%s条用例不相同\n' % i) f.write('expect:%s\n Actual:%s\n' % (expect, res)) fail_count.append(i) else: no_run_count.append(i) except Exception as e: #异常写入测试结果 self.data.write_result(i, str(e)) #报错写入指定路径文件 with open(log_file, 'a', encoding='utf-8') as f: f.write('\n第%s条测试用例' % i) initlogging(log_file, e) fail_count.append(i) self.send_email.send_main(pass_count, fail_count, no_run_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] no_run_count = [] rows_count = self.data.get_case_lines() # 每次执行用例之前将log日志文件清空数据 log_file = '../log/log.txt' with open(log_file, 'w') as f: f.seek(0, 0) # 加上f.seek(0),把文件定位到position 0;没有这句的话,文件是定位到数据最后,truncate也是从最后这里删除 f.truncate() # 清空数据 # 循环执行每行用例 for i in range(1, rows_count): try: is_run = self.data.get_is_run(i) if is_run: url = self.data.get_request_url(i) method = self.data.get_request_method(i) # 获取请求参数 data = self.data.get_data_value(i) # 获取excel文件中header关键字 header_key = self.data.get_request_header(i) # 获取json文件中header_key对应的头文件数据 header = self.data.get_header_value(i) expect = self.data.get_expect_data(i) depend_case = self.data.is_depend(i) if depend_case != None: self.depend_data = DependentData(depend_case) # 获取依赖字段的响应数据 depend_response_data = self.depend_data.get_value_for_key(i) # 获取请求依赖的key depend_key = self.data.get_depend_field(i) # 将依赖case的响应返回中某个字段的value赋值给该接口请求中某个参数 data[depend_key] = depend_response_data # cookie相关的没有跑通,代码逻辑是正常的,但是模拟登陆返回一直是非法请求 if header_key == 'write_Cookies': res = self.run_method.run_main(method, url, data, header, params=data) op_header = OperationHeader(res) op_header.write_cookie() elif header_key == 'get_Cookies': op_json = OperationJson('../dataconfig/cookie.json') cookie = op_json.get_data('apsid') cookies = {'apsid': cookie} res = self.run_method.run_main(method, url, data, header=cookies, params=data) else: res = self.run_method.run_main(method, url, data, header, params=data) ''' get请求参数是params:request.get(url='',params={}),post请求数据是data:request.post(url='',data={}) excel文件中没有区分直接用请求数据表示,则data = self.data.get_data_value(i)拿到的数据,post请求就是data=data,get请就是params=data ''' # excel中拿到的expect数据是str类型,但是返回的res是dict类型,两者数据比较必须都是字符类型 if self.com_util.is_contain(expect, json.dumps(res)): self.data.write_result(i, 'pass') pass_count.append(i) else: # 返回的res是dict类型,要将res数据写入excel中,需将dict类型转换成str类型 self.data.write_result(i, json.dumps(res)) with open(log_file, 'a', encoding='utf-8') as f: f.write("\n第%s条用例实际结果与预期结果不一致:\n" % i) f.write("Expected:%s\n Actual:%s\n" % (expect, res)) fail_count.append(i) else: no_run_count.append(i) except Exception as e: # 将异常写入excel的测试结果中 self.data.write_result(i, str(e)) # 将报错写入指定路径的日志文件里 with open(log_file, 'a', encoding='utf-8') as f: f.write("\n第%s条用例报错:\n" % i) initLogging(log_file, e) fail_count.append(i) self.send_mail.send_main(pass_count, fail_count, no_run_count)
def go_on_run(self): res = None # 定义三个列表,存储成功,失败,未执行的用例(case_id) pass_count = [] fail_count = [] no_run_count = [] # 每次执行用例之前将log日志文件清空数据 log_file = "D:\GZRJ\Python_XM\\api_automation_test\log\log.txt" with open(log_file,'w') as f: f.seek(0,0) # 加上f.seek(0),把文件定位到position 0;没有这句的话,文件是定位到数据最后,truncate也是从最后这里删除 f.truncate() # 先获取excel表格的行数 row_count = self.data.get_case_lines() print("start_用例开始执行,请稍候.....") for i in range(1, row_count): # 每循环一次,拿一次接口的所有数据 try: # 先拿到is_run判断是否执行,如果是yes(会返回Ture),就去拿其它数据 is_run = self.data.get_is_run(i) if is_run == True: method = self.data.get_request_method(i) url = self.data.get_request_url(i) data = self.data.get_data_for_json(i) header_key = self.data.is_header(i) # 获取excel文件中header关键字 header = self.data.get_header_value(i) # 获取json文件中header_key对应的头文件数据 expect = self.data.get_expcet_data(i) # 这里拿到的预期结果是字符串 # expect = self.data.get_expcet_data_for_mysql(i) # 断言方法如果是is_equal_dict就要取数据库这个值 depend_case = self.data.is_depend(i) # 获取依赖case_id # 判断是否有依赖id,然后把返回数据替换到请求数据 if depend_case != None: self.depend_data = DependdetData(depend_case) # 1.获取依赖的响应字段数据 depend_response_data = self.depend_data.get_data_for_key(i) # 2.获取需要替换的字段 depend_key = self.data.get_depend_field(i) # 3.把1步拿到的values去替换第2步拿到的字段 data[depend_key] = depend_response_data # 判断是否要写入,获取cookie if header_key == "write_Cookies": res = self.run_method.run_main(method, url, data, header, params=data) op_header = OperationHeader(res) op_header.write_cookie() res = res.json() # 先获取cookies再转成json字典类型,不然后面无法和预期结果对比 elif header_key == "get_Cookies": op_json = OperationJson("D:\GZRJ\Python_XM\\api_automation_test\dataconfig\cookie.json") cookie = op_json.get_data("PHPSESSID") cookies = {"PHPSESSID": cookie} #print(cookies) res = self.run_method.run_main(method, url, data, header, params=data, cookies=cookies).json() else: res = self.run_method.run_main(method, url, data, header, params=data).json() #print(res) #print(res["data"]["accessToken"]) # 判断预期结果是否在返回结果里面,需要把返回结果res转成json字符串中文和预期结果比较 if self.com_util.is_contain(expect, json.dumps(res, ensure_ascii=False)): self.data.write_result(i, "pass") pass_count.append(i) else: self.data.write_result(i, json.dumps(res, ensure_ascii=False)) with open(log_file, 'a', encoding='utf-8') as f: f.write("\n第%s条用例实际结果与预期结果不一致:\n" % i) f.write("Expected:%s\n Actual:%s\n" % (expect, res)) fail_count.append(i) # 如果is_run是no,会返回False,然后把当前的case_id(行号)写入no_run_count else: no_run_count.append(i) except Exception as e: # 将异常写入excel的测试结果中 self.data.write_result(i, str(e)) # 将报错写入指定路径的日志文件里 with open(log_file, 'a', encoding='utf-8') as f: f.write("\n第%s条用例报错:\n" % i) initLogging(log_file, e) fail_count.append(i) """ if self.com_util.is_equal_dict(expect, res): self.data.write_result(i, "PASS") pass_count.append(i) else: self.data.write_result(i, res) fail_count.append(i) """ #我这里打印了一下用例的执行情况,嘿嘿 print("end_用例执行完毕!") print("成功的用例:%s" % pass_count) print("失败的用例:%s" % fail_count)
def go_on_run(self): """程序执行""" pass_count = [] fail_count = [] no_run_count = [] res = None # 获取用例数 rows_count = self.data.get_case_lines() print(rows_count) # 第一行索引为0 for i in range(1, rows_count): print("i:", i) is_run = self.data.get_is_run(i) print(is_run) if is_run: url = self.data.get_request_url(i) print("url:", url) method = self.data.get_request_method(i) print("method:", method) request_data = self.data.get_data_for_json(i) print("request_data:", request_data) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$", type(request_data)) expect = self.data.get_expect_data(i) print("expect:", expect) header = self.data.is_header(i) print("header:", header) token = self.data.is_token(i) print("token:", token) depend_case = self.data.is_depend(i) print("depend_case:", depend_case) if depend_case != None: self.depend_data = DependentData(depend_case) # 获取依赖的响应数据 print("#### i", i) depend_response_data = self.depend_data.get_data_for_key(i) print("##################") print("1depend_response_data:", depend_response_data) # 获取依赖的key depend_key = self.data.get_depend_field(i) print("depend_key:", depend_key) # 更新请求字段 request_data.get( 'params')[depend_key] = depend_response_data #request_data = json.dumps(request_data, ensure_ascii=False) print("request_data:", request_data) print(type(request_data)) # 如果header字段值为write则将该接口的返回的token写入到token.json文件,如果为yes则读取token.json文件 if header == "write_token": print("********************") res = self.run_method.run_main(method, url, request_data).json() print("res:", res) print("res type", type(res)) #print("res.json():", res.json()) op_header = OperationHeader(res) op_header.write_token() elif header == 'write_cookie' and token == 'yes': print("case22222222222222") op_json = OperationJson("../dataconfig/token.json") token = op_json.get_data('data') request_data = dict(request_data, **token) # 把请求数据与登录token合并,并作为请求数据 print("login_data", request_data) res = self.run_method.run_main(method, url, request_data) print("res_login:"******"@@@@@@@@@@@@@@@@@@@@@@@@@@") op_json1 = OperationJson('../dataconfig/cookie.json') op_json2 = OperationJson('../dataconfig/token.json') cookies = op_json1.get_data('cookie') token = op_json2.get_data('data') request_data = dict(request_data, **token) print("post_data:", request_data) print("cookie:", cookies) new_value = json.dumps(request_data.get("params")) request_data["params"] = new_value res = self.run_method.run_main(method, url, request_data, cookies=cookies) print("res:", type(res)) else: res = self.run_method.run_main(method, url, request_data) if expect != None: if self.com_util.is_contain(expect, res): self.data.write_result(i, "Pass") pass_count.append(i) if type(res) is dict: self.data.write_real_res(i, json.dumps(res)) else: self.data.write_real_res(i, json.dumps(res.json())) else: self.data.write_result(i, "Fail") fail_count.append(i) if type(res) is dict: self.data.write_real_res(i, json.dumps(res)) else: self.data.write_real_res(i, json.dumps(res.json())) else: print(f"用例ID:case-{i},预期结果不能为空") else: self.data.write_result(i, "Not run") no_run_count.append(i) # 发送邮件 print(f"通过用例数:{len(pass_count)}") print(f"失败用例数:{len(fail_count)}") print(f"未执行败用例数:{len(no_run_count)}") self.send_email.send_main(pass_count, fail_count, no_run_count)
def go_on_run(self): res = None pass_count = [] fail_count = [] #10 0,1,2,3 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: url = self.data.get_request_url(i) method = self.data.get_request_method(i) request_data = self.data.get_data_for_json(i) # expect = self.data.get_expcet_data_for_mysql(i) expect = self.data.get_expcet_data(i) # print("except data is %s" %expect) header = self.data.is_header(i) depend_case = self.data.is_depend(i) response_value = self.data.get_response_result_field(i) is_post_previous_case = self.data.get_post_result(i) depend_excel_file = self.data.is_excel(i) if depend_case == None: if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif 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} if depend_excel_file == 'Y': files = { 'file': ('new1.xlsx', open("C:\\Users\\Aaron\\Desktop\\new1.xlsx", 'rb'), 'application/vnd.ms-excel') } res = self.run_method.run_main( method, url, request_data, headers, files, cookies) else: convert_data = json.dumps(request_data) res = self.run_method.run_main(method, url=url, data=convert_data, headers=headers, cookies=cookies) else: res = self.run_method.run_main(method, url, request_data) # res = self.run_method.run_main(method, url, request_data) elif depend_case == "write": if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif 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} if depend_excel_file == 'Y': files = { 'file': ('new1.xlsx', open("C:\\Users\\Aaron\\Desktop\\new1.xlsx", 'rb'), 'application/vnd.ms-excel') } res = self.run_method.run_main( method, url, request_data, headers, files, cookies) else: res = self.run_method.run_main( method, url, request_data, headers, cookies) else: res = self.run_method.run_main(method, url, request_data) # res = self.run_method.run_main(method, url, request_data) self.data.write_response_to_cell( i, res.content.decode("utf-8")) else: self.depend_data = DependdentData(depend_case) # 获取依赖的key depend_key = self.data.get_depend_field(i) if is_post_previous_case == 'N': depend_response_data = self.depend_data.get_data_for_excel( i) else: #获取的依赖响应数据 depend_response_data = self.depend_data.get_data_for_key( i) request_data[depend_key] = depend_response_data if header == 'write': res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_cookie() elif 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} files = { 'file': ('new1.xlsx', open("C:\\Users\\Aaron\\Desktop\\new1.xlsx", 'rb'), 'application/vnd.ms-excel') } request_data = json.dumps(request_data) print(type(request_data)) res = self.run_method.run_main(method, url=url, data=request_data, headers=headers, cookies=cookies) else: res = self.run_method.run_main(method, url, request_data) # if depend_case == "write": # self.data.write_response_to_cell(i,res.decode("utf-8")) # if self.com_util.is_equal_dict(expect,json.dumps(res)) == 0: if self.com_util.is_contain( expect, res.content.decode("utf-8")) == True: self.data.write_result(i, 'pass') pass_count.append(i) else: # self.data.write_result(i,json.dumps(res,ensure_ascii=False)) self.data.write_result(i, res.content.decode("utf-8")) fail_count.append(i) self.send_mai.send_main(pass_count, fail_count)