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)
class RunTest(object): def __init__(self): self.common_util = CommonUtil() self.send_email = SendEmail() self.connect_db = OperationMySQL() self.run_method = RunMethod() self.op_json = OperationJson() def run(self): res = None pass_count = [] fail_count = [] rows_count = self.connect_db.get_count() print(rows_count) for i in range(0, rows_count): run = self.connect_db.search('run', i) if run: url = self.connect_db.search('url', i) request_method = self.connect_db.search('request_method', i) request_data = self.op_json.get_data( self.connect_db.search('request_data', i)) expect = self.connect_db.search('expect', i) print(expect) res = self.run_method.run_main(request_method, url, request_data) print(res) if self.common_util.is_contain(expect, res) == 1: self.connect_db.write('pass', i + 1) pass_count.append(i + 1) print(pass_count) else: self.connect_db.write(res, i + 1) fail_count.append(i + 1) print(fail_count) self.send_email.send_main(pass_count, fail_count)
def get_data_for_json(self, row): # 不在构造函数,而在这里实例化,因为有的data不需要json opera_json = OperationJson() # 数据来源-excel,可直接调用 # request_data = opera_json.get_data(self.get_request_data()) request_data = opera_json.get_data(self.get_request_data(row)) return request_data
def getdata(self, row, json_data_name=None): opera_json = OperationJson(json_data_name) request_key = self.get_request_data(row) request_data = opera_json.get_data(request_key) if request_data == '': return None else: return request_data
def get_data_for_json(self, row): """ 通过json获取关键字对应的数据 :param row: 所在行数 :return: 关键字对应的数据 """ operation_json = OperationJson() return operation_json.get_data(self.get_request_data(row))
def get_request_for_json(self, rowx): oper_json = OperationJson() request_key = self.get_request_key(rowx) if request_key is None: request_data = None else: request_data = oper_json.get_data(request_key) return request_data
def get_data_for_json(self, row): opera_json = OperationJson() test = json.dumps(self.get_request_data(5)) print(test, '111') # request_data = opera_json.get_data(json.dumps(self.get_request_data(row))) request_data = opera_json.get_data( json.dumps(self.get_request_data(row))) return request_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 get_data_for_json(self, row): """ 通过关键字拿到data数据 :param row: :return: """ opera_json = OperationJson() request_data = opera_json.get_data(self.get_request_data(row)) return request_data
def go_on_run(self): """程序执行""" pass_count = [] fail_count = [] res = None # 获取用例数 rows_count = self.data.get_case_lines() # 第一行索引为0 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 = DependentData(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 # 如果header字段值为write则将该接口的返回的token写入到token.json文件,如果为yes则读取token.json文件 if header == "write": res = self.run_method.run_main(method, url, request_data) op_header = OperationHeader(res) op_header.write_token() elif header == 'yes': op_json = OperationJson("../dataconfig/token.json") token = op_json.get_data('data') request_data = dict(request_data, **token) # 把请求数据与登录token合并,并作为请求数据 res = self.run_method.run_main(method, url, request_data) 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) else: self.data.write_result(i, res) fail_count.append(i) else: print("用例ID:case-{i},预期结果不能为空") # 发送邮件 # self.send_email.send_main(pass_count, fail_count) print("通过用例数:{len(pass_count)}") print("失败用例数:{len(fail_count)}")
def get_data_for_json(self, row): """ 通过关键字拿到data数据 :param row: :return: """ print("1111111111111", row) opera_json = OperationJson() print("22222222222222222") print(self.get_request_data(row)) request_data = opera_json.get_data(self.get_request_data(row)) print("request_data:", request_data) return request_data
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): """ 执行测试用例 :return: 通过用例和失败用例 """ pass_list = [] fail_list = [] rows_count = self.data.get_case_num() for i in range(1, rows_count): is_run = self.data.is_run(i) if is_run: url = self.data.get_request_url(i) method = self.data.get_method(i) data = self.data.get_data_for_json(i) cookie = self.data.is_cookie(i) header = self.data.is_header(i) expect = self.data.get_expect_data(i) if isinstance(expect, float): expect = str(int(expect)) depend_case = self.data.is_depend(i) if depend_case is not None: depend_data = DependentData(depend_case) # 获取依赖响应的返回数据 depend_response_data = depend_data.get_data_for_key(i) # # 使用mock-test模拟请求 # depend_response_data = mock_test(self.run_method.run_main, data, url, "POST", order) # 获取依赖的字段 depend_field = self.data.get_depend_field(i) # 更新 data[depend_field] = depend_response_data if cookie == 'write': res = self.run_method.run_main(method, url, data, header) opera_cookie = OperationCookie(res) opera_cookie.write_cookie() elif cookie == 'yes': op_json = OperationJson('../data_config/cookie.json') cookie = op_json.get_data('ASP.NET_SessionId') cookies = {'ASP.NET_SessionId': cookie} res = self.run_method.run_main(method, url, data, cookies) else: res = self.run_method.run_main(method, url, data) if self.common_util.is_contain(expect, res.text): # print("PASS") pass_list.append(i) self.data.write_result(i, 'PASS') else: # print("FAILED") fail_list.append(i) self.data.write_result(i, 'FAILED') self.send_email.send_main(pass_list, fail_list)
def go_on_run(self, request_value, reponse_value): 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) # request_data = self.data.get_request_for_json(i) # expected = self.data.get_expected_result(i) fix_request_key = self.data.get_fix_request_key(i) if fix_request_key is not None: request_data = self.run_request_data(i, request_value) expected = self.run_expected_data(i, reponse_value) else: 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 == 'write': # res = self.run.run_main(url, method, request_data) # oper_header = OperationHeader() # oper_header.write_cookie() if header == 'yes': op_json = OperationJson('../dataconfig/esage_cookies.json') cookie = op_json.get_data('Cookie') cookies = {'Cookie': cookie} res = self.run.run_main(url, method, request_data, cookies) 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)
def run_depnedent(self): run_method = RunMethod() row_num = self.operation.get_rows_num(self.case_id) # 获取行号 request_data = self.data.get_json_data(row_num) # 获取请求数据 method = self.data.get_request_method(row_num) # 获取请求方法 url = self.data.get_request_url(row_num) cookies = {"SESSION": "bdbd5d09-29c5-40f8-aa16-cae274c1c6cd"} cookie = self.data.get_cookies_value(row_num) if cookie == 'yes': get_cookie = OperationJson('../dataconfig/cookie.json') cooki = get_cookie.get_data('SESSION') cookies = {"SESSION": cooki} res = run_method.run_main(method, url, request_data, cookies) # 发送请求 else: res = run_method.run_main(method, url, request_data) return json.loads(res)
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)
def get_data_for_key(self, row): """ 获取响应数据中的依赖返回值 :param row: 行数 :return: 依赖返回值 """ depend_data = self.data.get_depend_key(row) response_data = self.run_dependent() if "validateCookie" in depend_data: cookie = OperationCookie(response_data) cookie.write_cookie() code = OperationJson('../data_config/cookie.json') return code.get_data(depend_data)[8:] else: json_rules = parse(depend_data) result = json_rules.find(json.loads(response_data.text)) return [math.value for math in result][0]
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_no_run(self, i): rows_conut = self.data.get_case_lines() # 获取行数 is_run = self.data.get_is_run(i) print(is_run) if is_run: url = self.data.get_url(i) method = self.data.get_request_way(i) # 获取请求的方法 request_data = self.data.get_json_data(i) # 获取请求数据 data_type = self.data.get_data_type(i) print(data_type) cookie = self.data.get_is_cookies(i) # 获取cookies expect = self.data.get_expect(i) # 获取预期结果 result = self.data.get_result(i) depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid if depend_case is not None: # 获取替换请求字段 depend_key = self.data.get_depned_key(i) # 获取依赖的响应数据 self.depend_data = DependData(depend_case) depend_response_data = self.depend_data.get_depned_value(i) split = len(depend_key.split(">")) # 切割替换的字段 # 根据请求字段的个数替换 for y in range(0, split): re = depend_key.split(">") request_data[re[y]] = depend_response_data[y] if cookie == 'write': res = self.run_method.run_main(method, url, request_data) op_cookie = OperationCookie(res) # 获取cookies op_cookie.write_cookie() # 写入cookies elif cookie == 'yes': get_cookies = OperationJson('../data/scm-cookies.json') cooki = get_cookies.get_data('SESSION') cookies = {"SESSION": cooki} res = self.run_method.run_main(method, url, request_data, cookies, data_type) else: res = self.run_method.run_main(method, url, request_data) if self.is_contain.is_contain(expect, res): self.data.write_data(i, 'pass') print(res) else: self.data.write_data(i, 'fail') print(res)
class GetData(object): """这是GetData""" def __init__(self): self.op_excel = OperationExcel() self.op_json = OperationJson() def get_case_lines(self): return self.op_excel.get_line_length() def get_request_url(self, row): col = global_var.get_col_url() return self.op_excel.get_cell_value(row, col) def get_request_method(self, row): col = global_var.get_col_method() return self.op_excel.get_cell_value(row, col) def get_request_data(self, row): col = global_var.get_col_data() return self.op_excel.get_cell_value(row, col) def get_is_run(self, row): col = global_var.get_col_run() return self.op_excel.get_cell_value(row, col) # 根据关键字获取请求数据json def get_request_data_by_json(self, row): key = self.get_request_data(row) return self.op_json.get_data(key) def get_header(self, row): col = global_var.get_col_header() return self.op_excel.get_cell_value(row, col) def get_expect_result(self, row): col = global_var.get_col_expect() return self.op_excel.get_cell_value(row, col) def write_actual_result(self, row, result): col = global_var.get_col_actual() return self.op_excel.write_cell_value(row, col, result)
class GetData: def __init__(self): self.opera_excel = OperationExcel() #获取excel行数,即case个数 def get_case_lines(self): return self.opera_excel.get_lines() #获取是否执行 def get_is_run(self, row): flag = None col = int(data_config.get_run()) run_model = self.opera_excel.get_cell_value(row, col) if run_model == 'yes': flag = True else: flag = False return flag #是否携带header def get_is_header(self, row): col = int(data_config.get_header()) header = self.opera_excel.get_cell_value(row, col) if header == 'yes': return data_config.get_header_value() else: return None #获取请求方式 def get_request_method(self, row): col = int(data_config.get_run_way()) request_method = self.opera_excel.get_cell_value(row, col) return request_method #获取url def get_request_url(self, row): col = int(data_config.get_url()) url = self.opera_excel.get_cell_value(row, col) return url #获取请求数据 def get_request_data(self, row): col = int(data_config.get_data()) data = self.opera_excel.get_cell_value(row, col) if data == '': return None else: return data #通过获取关键字拿到data数据 def get_data_for_json(self, row): self.opera_json = OperationJson() request_data = self.opera_json.get_data(self.get_request_data(row)) return request_data #获取预期结果 def get_expect_data(self, row): col = int(data_config.get_expect()) expect = self.opera_excel.get_cell_value(row, col) if expect == '': return None return expect #通过sql获取预期结果 def get_expect_data_for_sql(self, row): op_mysql = OperationSql() sql = self.get_expect_data(row) res = op_mysql.search_one(sql) return res #将运行结果写入excel def write_result(self, row, value): col = int(data_config.get_result()) self.opera_excel.write_value(row, col, value) #获取依赖数据的key def get_depend_key(self, row): col = int(data_config.get_data_depend()) depend_key = self.opera_excel.get_cell_value(row, col) if depend_key == '': return None else: return depend_key #判断是否有case依赖 def is_depend(self, row): col = int(data_config.get_case_depend()) depend_case_id = self.opera_excel.get_cell_value(row, col) if depend_case_id == '': return None else: return depend_case_id #获取数据依赖字段 def get_depend_field(self, row): col = int(data_config.get_field_depend()) data = self.opera_excel.get_cell_value(row, col) if data == '': return None else: return data
def go_no_run(self): 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: url = self.data.get_url(i) case_name = self.data.get_case_name(i) method = self.data.get_request_way(i) # 获取请求的方法 request_data = self.data.get_json_data(i) # 获取请求数据 data_type = self.data.get_data_type(i) cookie = self.data.get_is_cookies(i) # 获取cookies expect = self.data.get_expect(i) # 获取预期结果 depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid if depend_case is not None: # 获取替换请求字段 depend_key = self.data.get_depned_key(i) # 获取依赖的响应数据 self.depend_data = DependData(depend_case) depend_response_data = self.depend_data.get_depned_value(i) split = len(depend_key.split(">")) # 切割替换的字段 # 根据请求字段的个数替换 for y in range(0, split): re = depend_key.split(">") request_data[re[y]] = depend_response_data[y] if cookie == 'write': res = self.run_method.run_main(method, url, request_data) op_cookie = WriteCookies(res) # 获取cookies op_cookie.write_cookie() # 写入cook ies elif cookie == 'yes': get_cookies = OperationJson('../data/scm-cookies.json') coo = get_cookies.get_data('SESSION') cooki = {"SESSION": coo} res = self.run_method.run_main(method, url, request_data, cooki, data_type) else: # get_cookies = OperationJson('../data/scm-cookies.json') # cooki = get_cookies.get_data('accessToken') # request_data['accessToken'] = cooki res = self.run_method.run_main(method, url, request_data) if self.is_contain.is_contain(expect, res): self.data.write_data(i, 'pass') self.logger.info("第" + str(i) + "个case-->" + case_name + ": 测试通过") self.logger.info("url--> " + url) self.logger.info("request_data-->" + str(request_data)) self.logger.info("response_data-->" + res) print("第" + str(i) + "个case-->" + case_name + ": 测试通过") print(res) else: self.data.write_data(i, res) self.logger.info("第" + str(i) + "个case-->" + case_name + ": 测试失败") self.logger.info("url--> " + url) self.logger.info("request_data-->" + str(request_data)) self.logger.info("response_data-->" + res) print("第" + str(i) + "个case-->" + "测试失败") print(res)
class GetData: def __init__(self): self.opera_excel = OperationExcel() self.opera_json = OperationJson() self.opera_header = op_header_json() self.data_config = data.data_config #self.data_config = self.data.data_config def get_case_lines(self): return self.opera_excel.get_lines() #获取是否执行 def get_is_run(self,row): flag = None col = int(self.data_config.get_run()) run_model = self.opera_excel.get_cell_value(row,col) if run_model == 'yes': flag = True else: flag = False return flag #是否有header def is_header(self,row): col = int(self.data_config.get_header()) header = self.opera_excel.get_cell_value(row,col) return header #根据获取到header值,获取json数据 def get_header_json(self,row): header = self.is_header(row) if header != None: return self.opera_header.get_header_value(header) else: return None #获取请求方式 def get_request_methon(self,row): col = int(self.data_config.get_run_way()) request_method = self.opera_excel.get_cell_value(row,col) return request_method #获取url def get_url(self,row): col = int(self.data_config.get_url()) url = self.opera_excel.get_cell_value(row,col) return url #获取请求数据 def get_request_data(self,row): col = int(self.data_config.get_data()) data = self.opera_excel.get_cell_value(row,col) if data != '': return data else: return None #通过关键字获取data数据 def get_data_for_json(self,row): request_data = self.get_request_data(row) if request_data != None: data = self.opera_json.get_data(request_data) else: return None return data #获取预期结果 def get_except_data(self,row): col = int(self.data_config.get_expect()) request_data = self.opera_excel.get_cell_value(row,col) if request_data !='': return request_data else: return None def write_result(self,row,value): col = int(self.data_config.get_result()) self.opera_excel.write_value(row,col,value) # if __name__ == '__main__': # getdata=GetData() # print(getdata.get_header_json(1)) # print(getdata.get_except_data(1))
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 get_data_for_json(self, row): opera_json = OperationJson() request_data = opera_json.get_data(self.get_request_data(row)) return request_data
class GetData: def __init__(self): self.opera_excel = OperationExcel() self.opera_json = OperationJson() #获取excel行数, def get_case_lines(self): return self.opera_excel.get_lines() #获取是否执行 def get_is_run(self, row): flag = None col = int(data_config.get_run()) run_model = self.opera_excel.get_cell_value(row, col) if run_model == 'yes': flag = True else: flag = False return flag #是否携带hearder def is_header(self, row): col = int(data_config.get_header()) header = self.opera_excel.get_cell_value(row, col) if header == 'yes': headerJson = data_config.get_header_value() return headerJson else: return None #获取请求方式 def get_request_method(self, row): col = int(data_config.get_run_way()) request_method = self.opera_excel.get_cell_value(row, col) return request_method #获取url def get_request_url(self, row): col = int(data_config.get_url()) url = self.opera_excel.get_cell_value(row, col) return url #获取请求数据 def get_request_data(self, row): col = int(data_config.get_data()) data = self.opera_excel.get_cell_value(row, col) if data == '': return None return data #通过获取关键字拿到data数据 def get_data_for_json(self, row): res = self.get_request_data(row) request_data = self.opera_json.get_data(res) return request_data #获取预期结果 def get_expcet_data(self, row): col = int(data_config.get_expect()) expect = self.opera_excel.get_cell_value(row, col) if expect == '': return None else: return expect #结果写入 def write_res(self, row, value): col = int(data_config.get_result_value()) self.opera_excel.write_value(row, col, value) #状态写入 def write_status(self, row, value): col = int(data_config.get_result()) self.opera_excel.write_value(row, col, value) def get_case_depend(self, row): case_col = int(data_config.get_case_depend()) case = self.opera_excel.get_cell_value(row, case_col) rowRes = self.opera_excel.get_cell_row(case) res = None if rowRes: result_col = int(data_config.get_result_value()) resData = self.opera_excel.get_value(rowRes, result_col) if resData: resData = json.loads(resData) data_col = int(data_config.get_data_depend()) data = self.opera_excel.get_cell_value(row, data_col) field_col = int(data_config.get_field_depend()) field = self.opera_excel.get_cell_value(row, field_col) if field: res = resData[data][field] else: res = resData[data] return res
def get_json_data(self, row): operation = OperationJson() json_data = operation.get_data(self.get_request_data(row)) return json_data
def go_no_run(self): 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: url = self.data.get_url(i) case_name = self.data.get_case_name(i) method = self.data.get_request_way(i) # 获取请求的方法 request_data = self.data.get_json_data(i) # 获取请求数据 data_type = self.data.get_data_type(i) cookie = self.data.get_is_cookies(i) # 获取cookies expect = self.data.get_expect(i) # 获取预期结果 depend_case = self.data.get_depend_case_id(i) # 获取依赖的caseid if depend_case is not None: # 获取替换请求字段 depend_key = self.data.get_depned_key(i) # 获取依赖的响应数据 self.depend_data = DependData(depend_case) depend_response_data = self.depend_data.get_depned_value(i) split = len(depend_key.split(">")) # 切割替换的字段 # 根据请求字段的个数替换 for y in range(0, split): re = depend_key.split(">") request_data[re[y]] = depend_response_data[y] if cookie == 'write': res = self.run_method.run_main(method, url, request_data) op_cookie = WriteCookies(res) # 获取cookies op_cookie.write_cookie() # 写入cook ies elif cookie == 'yes': father_path = os.path.join( os.path.dirname( os.path.dirname(os.path.abspath(__file__))), 'data') file_path = os.path.join(father_path, '金城-cookies.json') get_cookies = OperationJson(file_path) cooki = get_cookies.get_data('accessToken') request_data['accessToken'] = cooki res = self.run_method.run_main(method, url, request_data, data_type) else: father_path = os.path.join( os.path.dirname( os.path.dirname(os.path.abspath(__file__))), 'data') file_path = os.path.join(father_path, '金城-cookies.json') get_cookies = OperationJson(file_path) cooki = get_cookies.get_data('accessToken') request_data['accessToken'] = cooki res = self.run_method.run_main(method, url, request_data) if self.is_contain.is_contain(expect, res): self.data.write_data(i, 'pass') # self.logger.info("第" + str(i) + "个case-->" + case_name + ": \033[31m测试通过\033[0m") self.logger.info("第%s 个case-->%s: 测试通过" % (str(i), case_name)) self.logger.info("url--> " + url) self.logger.info("request_data-->" + str(request_data)) self.logger.info("response_data-->" + res) print("第" + str(i) + "个case-->" + case_name + ": 测试通过") # print("第" + str(i) + "个case-->" + case_name + ": \033[32m测试通过\033[0m") else: self.data.write_data(i, res) self.logger.info("第" + str(i) + "个case-->" + case_name + ": 测试失败") self.logger.info("url--> " + url) self.logger.info("request_data-->" + str(request_data)) self.logger.info("response_data-->" + res) # print("第" + str(i) + "个case-->" + "\033[35m测试失败\033[0m") print("第%s 个case-->%s: 测试失败" % (str(i), case_name))
def get_data_value(self, row): oper_json = OperationJson( r'E:\pyScript\python3_interface-master\dataconfig\request_data.json' ) request_data = oper_json.get_data(self.get_request_data(row)) return request_data
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)