def test_register(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据转换为字典 actual_value = res.json() # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: # unittest 的断言方法 # self.assertEqual(actual_value['code'], excepted_result) # 第三个参数为:如果断言失败,会提示msg信息 self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) # self.assertEqual(actual_value.get('code'), excepted_result) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result}\n具体异常为:\n{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_todo(self, case): # 2. 拼接完整的url new_url = do_yaml.read('api', 'prefix') + case.url # 3. 向服务器发起请求 res = self.do_request.send(url=new_url, # url地址 method=case.method, # 请求方法 data=case.data # 请求参数 # is_json=True # 是否以json格式来传递数据, 默认为True ) # 将相应报文中的数据转化为字典 actual_value = res.json() # 获取用例的行号 row = case.case_id + 1 # 将expected期望值转化为字典 expected_result = json.loads(case.expected, encoding='utf-8') msg = case.title # 获取标题 success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示 fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示 try: # 先断言code, 再断言msg self.assertEqual(expected_result.get('code'), actual_value.get('code'), msg=msg) self.assertEqual(expected_result.get('msg'), actual_value.get('msg'), msg=msg) except AssertionError as e: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # do_log.error("断言异常: {}".format(e)) do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: if "token" in res.text: token = actual_value.get('data')['token'] # 获取token信息 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
def test_login(self, case): #参数化 new_data = Parameterize.to_param(case.data) #构造请求url new_url = do_yaml.read("api", "profix") + case.url #发起请求 res = self.do_request.send(url=new_url, data=new_data) #将响应报文转化为json actual_value = res.json() # 获取测试用例行号 row = case.case_id + 1 # 获取预期结果 expected_result = json.loads(case.expected, encoding="utf8") #获取测试用例的标题 msg = case.title success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示 fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示 try: # 先断言code, 再断言msg self.assertEqual(expected_result.get("code"), actual_value.get("code"), msg=msg) self.assertEqual(expected_result.get("msg"), actual_value.get("msg"), msg=msg) except Exception as e: # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # error 指的时日志的收集等级 do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) # info 指的时日志的收集等级 do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") finally: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text)
def test_register(self, case): """ 测试用户注册接口 :return: """ #处理获取的表数据 msg = case['title'] url = http_host + case['url'] data = eval(Context.replace_all(str(case['data']))) method = case['method'] except_result = case['expected'] # 创建一个webservice请求对象 dowebservice = DoWebService(url=url) #发起数据请求 request_res = dowebservice.webservice_requests(post=method, param=data) # 判断请求方式是否有误 if request_res == 'PostError': do_log.info('{}\t执行请求方式有误!:{}\n'.format(msg, case['method'])) # 判断是否为发送验证码接口并获取数据库验证码信息 if 'ok' in str(request_res) and case['method'].lower() == 'sendmcode': setattr(Context, "invest_mobile_num", data["mobile"]) check_sql = case['check_sql'] if check_sql: check_sql = Context.replace_all(check_sql) mysql_data = self.do_mysql.select_mysql(sql=check_sql) mcode = mysql_data['Fverify_code'] # 动态创建Context对象变量sql_mcode(验证码) setattr(Context, "sql_mcode", mcode) try: #断言请求结果 self.assertIn(except_result, str(request_res), msg=msg + '失败!') # 判断是否为用户注册接口并获取数据库用户信息 if 'ok' in str( request_res) and case['method'].lower() == 'userregister': check_sql = case['check_sql'] #动态创建Context对象变量user_id(用户名) setattr(Context, 'user_id', data['user_id']) if check_sql: check_sql = Context.replace_all(check_sql) mysql_data = self.do_mysql_user.select_mysql(sql=check_sql) if mysql_data['Fuid'] is not None: # 动态创建Context对象变量Fuid(数据库中获取的用户ID) setattr(Context, 'Fuid', mysql_data['Fuid']) #断言用户是否添加成功 self.assertIsNotNone(mysql_data, msg=msg + '数据库添加用户失败!') do_log.info('{}\t执行结果:{}\n'.format(msg, 'Pass')) do_excel.write_result(case['case_id'] + 1, str(request_res), 'Pass') except AssertionError as e: do_log.error('{}执行结果:{}\t报错信息:{}\n'.format(msg, 'Fail', e)) do_excel.write_result(case['case_id'] + 1, str(request_res), 'Fail') raise e
def test_recharge(self, one_testcase): new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 1、在充值之前,查询当前用例的金额 # 在发起请求之前, 查询当前账户金额 check_sql = one_testcase.check_sql if check_sql: check_sql = Parameterize.to_parma(check_sql) mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_before = float(mysql_data['leave_amount']) # 不是float浮点数, 也不是int类型, 是decimal数据类型 # 2、进行充值 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # one_testcase.expected_value为int类型,需要转化为字符串类型 # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) # 3、查询充值成功之后的金额 # 如果check_sql不为空, 说明要进行数据校验 if check_sql: mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_after = float(mysql_data['leave_amount']) one_dict = json.loads(new_data, encoding='utf-8') currrent_recharge_amount = one_dict['amount'] actual_amount = amount_before + currrent_recharge_amount self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误") except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = actual_value["data"]["token_info"]["token"] # add_headers需要传字典类型 # self.do_request.add_headers("Authorization", f"Bearer {token}") headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) self.do_excel.write_data(one_testcase, res.text, "成功")
def test_addition(self, case): #参数化 new_data = Parameterize.to_param(case.data) #构造请求url new_url = do_yaml.read("api", "profix") + case.url #发起加标请求 res = self.do_request.send(url=new_url, data=new_data) #将相应报文中的数据转化为字典 actul_value = res.json() #获取测试用例所在的行 row = case.case_id + 1 # 获取预期结果 expected_result = case.expected #获取测试用例标题 msg = case.title success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示 fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示 try: self.assertEqual(expected_result, actul_value.get("code"), msg=msg) except Exception as e: # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: if "token_info" in res.text: token = actul_value["data"]["token_info"]["token"] header = {"Authorization": "Bearer " + token} self.do_request.add_headers(header) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) # info 指的时日志的收集等级 do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") finally: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text)
def test_invest(self, one_testcase): if 8 >= one_testcase.id >= 3: self.do_request.get_ids() elif 22 >= one_testcase.id >= 15: self.do_request.get_gjids() elif 38 >= one_testcase.id >= 33: self.do_request.get_ghxsid() new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行加标 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: self.assertEqual(one_testcase.expected_value, actual_value.get("errcode"), one_testcase.name) except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token" in res.text and one_testcase.id == 1: token = res.json()["data"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # check_sql_str = one_testcase.check_sql # if check_sql_str: # # 将check_sql json格式的字符串转化为字典 # check_sql_dict = json.loads(check_sql_str, encoding='utf-8') # if 'loan_id' in check_sql_dict: # # 获取查询loan id的sql语句 # loan_id_sql = check_sql_dict.get('loan_id') # # 将sql语句进行参数化 # loan_id_sql = Parameterize.to_parma(loan_id_sql) # mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) # # load_id = mysql_data['id'] # 获取loan_id # # 设置loan_id为GlobalData的类属性 # setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
def test_invest(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行投资 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) check_sql_str = one_testcase.check_sql if check_sql_str: # 将check_sql json格式的字符串转化为字典 check_sql_dict = json.loads(check_sql_str, encoding='utf-8') if 'loan_id' in check_sql_dict: # 获取查询loan id的sql语句 loan_id_sql = check_sql_dict.get('loan_id') # 将sql语句进行参数化 loan_id_sql = Parameterize.to_parma(loan_id_sql) mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) load_id = mysql_data['id'] # 获取loan_id # 设置loan_id为GlobalData的类属性 setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
def test_add(self, case): # 将期望结果取出 expected = case.expected # 参数化,将取出来的字符串进行参数替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 向接口发起请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str) # 获取的报文转换为字典 result = res.json() msg = case.title # 获取用例标题 success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected, result['code'], msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if 'token_info' in res.text: self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def test_ride(self,one_case): actual_results = Jisuan(one_case['l_data'], one_case['r_data']).ride() msg = one_case['title'] expected_results = one_case['expected'] success_msg = do_config.get_config("msg", "success_result") fail_msg = do_config.get_config("msg", "Fail_result") try: self.assertEqual(expected_results,actual_results, msg=msg) # self.rizhi.write("test_ride:{} ,测试结果为 {}\n".format(msg,success_msg)) do_log.info("test_ride:{} ,测试结果为 {}\n".format(msg, success_msg)) do_excel.write_result(one_case['case_id']+1,actual_results,success_msg) except AssertionError as e: # self.rizhi.write("test_ride:{} ,测试结果为 {}.具体异常为{}\n".format(msg,fail_msg,e)) do_log.error("test_ride:{} ,测试结果为 {}.具体异常为{}\n".format(msg,fail_msg,e)) do_excel.write_result(one_case['case_id'] + 1, actual_results, fail_msg) raise e #因为上面捕获了异常,所以这里用raise来返回异常
def test_invest(self, data_namedtuple): """ 测试投资功能 :return: """ do_log.info("\n正在运行的测试用例为:{}".format(data_namedtuple.title)) method = data_namedtuple.method url = do_config("api", "url") + data_namedtuple.url print(url) new_data = HandleContext().invest_parameterization(data_namedtuple.data) print(new_data) response = self.send_request(method=method, url=url, data=new_data) print(response.text) # 判断服务器是否有异常 try: self.assertEqual(200, response.status_code, msg="测试【{}】失败,http请求状态码为【{}】". format(data_namedtuple.title, response.status_code)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) raise e # 判断是否加标成功,加标成功,获取loan_id if response.json().get("msg") == "加标成功": check_sql = data_namedtuple.check_sql if check_sql: check_sql = HandleContext().invest_parameterization(check_sql) mysql_data = self.handle_mysql(sql=check_sql) # 获取一条记录 HandleContext.loan_id = mysql_data["Id"] # 动态添加属性,获取标的Id # setattr(HandleContext, "loan_id", mysql_data["Id"]) # 动态创建类属性,获取标的Id # 验证预期结果是否与实际结果相同 try: self.assertEqual(data_namedtuple.expected, response.text, msg="测试{}失败".format(data_namedtuple.title)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) self.do_excel.write_result(row=data_namedtuple.case_id+1, actual=response.text, result=do_config("msg", "fail_result")) raise e else: self.do_excel.write_result(row=data_namedtuple.case_id+1, actual=response.text, result=do_config("msg", "success_result"))
def test_login(self, case): # 将期望结果取出并转换为字典 expected = json.loads(case.expected, encoding='utf-8') # 参数化,将取出来的字符串进行手机号替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 将此处的功能模块替换为接口请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str ) result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected['code'], result['code'], msg=msg) self.assertEqual(expected['msg'], result['msg'], msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'result_col'), value=success_msg) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'actual_col'), value=res.text )
def __call__(self, url, api, data): if isinstance(data, str): try: data = json.loads(data) except Exception as e: do_log.error(e) do_log.error("{}不是json格式!".format(data)) data = eval(data) client = Client(url=url) if api.lower() == 'sendmcode': try: res = client.service.sendMCode(data) except Exception as e: return e.fault.faultstring else: return res.retInfo if api.lower() == 'userregister': try: res = client.service.userRegister(data) except Exception as e: return e.fault.faultstring else: return res.retInfo if api.lower() == 'verifyuserauth': try: res = client.service.verifyUserAuth(data) except Exception as e: return e.fault.faultstring else: return res.retInfo if api.lower() == 'bindbankcard': try: res = client.service.bindBankCard(data) except Exception as e: return e.fault.faultstring else: return res.retInfo
def test_login(self, data_namedtuple): """ 测试登录功能 :return: """ url = do_config("api", "url") + data_namedtuple.url new_data = HandleContext().login_parameterization(data_namedtuple.data) do_log.info("\n正在运行的测试用例为:{}".format(data_namedtuple.title)) response = self.send_request(method=data_namedtuple.method, url=url, data=new_data) # 判断服务器是否有异常 try: self.assertEqual(200, response.status_code, msg="测试【{}】失败,http请求状态码为【{}】".format( data_namedtuple.title, response.status_code)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) raise e try: self.assertEqual(data_namedtuple.expected, response.text, msg="测试{}失败".format(data_namedtuple.title)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) self.do_excel.write_result(row=data_namedtuple.case_id + 1, actual=response.text, result=do_config("msg", "fail_result")) raise e else: self.do_excel.write_result(row=data_namedtuple.case_id + 1, actual=response.text, result=do_config( "msg", "success_result"))
def test_add(self, data_namedtuple): """ 测试加标功能 :return: """ url = do_config("api", "url") + data_namedtuple.url new_data = HandleContext().add_parameterization(data_namedtuple.data) print(new_data) do_log.info("\n正在运行的测试用例为:{}".format(data_namedtuple.title)) # 接口不支持json格式,只支持form表单,is_json=False, 使用data response = self.send_request(method=data_namedtuple.method, url=url, data=new_data) print(response.text) # 判断服务器是否有异常 try: self.assertEqual(200, response.status_code, msg="测试【{}】失败,请求状态码为【{}】" .format(data_namedtuple.title, response.status_code)) except AssertionError as e : # 出现异常,后面代码不会执行 do_log.error("{},执行结果:{}\n具体异常信息:{}\n".format(data_namedtuple.title, "fail", e)) raise e try: self.assertEqual(data_namedtuple.expected, response.text, msg="测试{}失败".format(data_namedtuple.title)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) self.do_excel.write_result(row=data_namedtuple.case_id+1, actual=response.text, result=do_config("msg", "fail_result")) raise e else: self.do_excel.write_result(row=data_namedtuple.case_id+1, actual=response.text, result=do_config("msg", "success_result"))
def test_invest(self, case): # 1. 参数化 new_data = Parameterize.to_param(case.data) # 2. 拼接完整的url new_url = do_yaml.read('api', 'prefix') + case.url # 3. 向服务器发起请求 res = self.do_request.send(url=new_url, data=new_data) # 将相应报文中的数据转化为字典 actual_value = res.json() row = case.case_id + 1 expect_result = case.expected msg = case.title # 获取用例标题 success_msg = do_yaml.read("msg", "success_result") # 获取用例执行成功的提示信息 fail_msg = do_yaml.read("msg", "fail_result") # 获取用例执行失败的提示信息 try: self.assertEqual(expect_result, actual_value.get('code'), msg=msg) except AssertionError as e: # 将执行结果写入到日志中 do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") # 将响应数据写入excel self.do_excel.write_data(row=row, column=do_yaml.read( "excel", "actual_col"), value=res.text) # 将测试结果写入excel self.do_excel.write_data(row=row, column=do_yaml.read( "excel", "result_col"), value=fail_msg) raise e else: # 如果登录接口断言成功, 则取出token, 并添加到公共请求头中 if 'token_info' in res.text: token = actual_value['data']['token_info']['token'] headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # 取出load id的第一种方法 # check_sql = case.check_sql # 取出check_sql # if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验 # check_sql = Parameterize.to_param(check_sql) # 将check_sql进行参数化 # mysql_data = self.do_mysql.run(check_sql) # 执行sql # load_id = mysql_data['id'] # # 动态创建属性的机制, 来解决接口依赖的问题 # setattr(Parameterize, 'loan_id', load_id) # check_sql = json.loads(case.check_sql, encoding='utf-8') # if 'load_id' in check_sql: # pass # 取出load id的第二种方法 # if case.case_id == 2: # load_id = actual_value.get('data').get('id') # setattr(Parameterize, 'loan_id', load_id) # 将执行结果写入到日志中 do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") # 将响应数据写入excel self.do_excel.write_data(row=row, column=do_yaml.read( "excel", "actual_col"), value=res.text) # 将测试结果写入excel self.do_excel.write_data(row=row, column=do_yaml.read( "excel", "result_col"), value=success_msg)
def test_recharge(self, data_namedtuple): """ 测试充值功能 :return: """ do_log.info("\n正在运行的测试用例为:{}".format(data_namedtuple.title)) method = data_namedtuple.method url = do_config("api", "url") + data_namedtuple.url new_data = HandleContext().recharge_parameterization( data_namedtuple.data) check_sql = data_namedtuple.check_sql # 充值之前用户的剩余金额 if check_sql: check_sql = HandleContext().recharge_parameterization(check_sql) mysql_data = self.handle_mysql(sql=check_sql) # 获取一条记录 amount_before_recharge = float( mysql_data["LeaveAmount"]) # decimal类型数据转换成float类型 amount_before_recharge = round(amount_before_recharge, 2) # 保留两位小数 response = self.send_request(method=method, url=url, data=new_data) # 判断服务器是否有异常 try: self.assertEqual(200, response.status_code, msg="测试【{}】失败,http请求状态码为【{}】".format( data_namedtuple.title, response.status_code)) except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) raise e response = response.text # 获取json格式数据 # 将复杂的数据赋值为空,之后单独验证 if check_sql: response = json.loads(response, encoding="utf8") response["data"] = None response = json.dumps( response, ensure_ascii=False) # ensure_ascii为False,可将乱码转换成中文 # 验证预期结果是否与实际结果相同 try: self.assertEqual(data_namedtuple.expected, response, msg="测试{}失败".format(data_namedtuple.title)) # 充值之后用户的剩余金额 if check_sql: check_sql = HandleContext().recharge_parameterization( check_sql) mysql_data = self.handle_mysql(sql=check_sql) amount_after_recharge = float(mysql_data["LeaveAmount"]) actual_amount = round(amount_after_recharge, 2) recharge_amount = float( json.loads(new_data, encoding="utf8").get("amount")) excepted_amount = round( amount_before_recharge + recharge_amount, 2) # 服务器返回复杂数据的验证,这里验证充值金额 self.assertEqual(excepted_amount, actual_amount, msg="数据库中充值的金额有误") except AssertionError as e: do_log.error("\n具体异常信息为:{}\n".format(e)) self.do_excel.write_result(row=data_namedtuple.case_id + 1, actual=response, result=do_config("msg", "fail_result")) raise e else: self.do_excel.write_result(row=data_namedtuple.case_id + 1, actual=response, result=do_config( "msg", "success_result"))
def test_recharge(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 获取充值前的账户金额 # 根据excel中sql语句是否存在来判断是否获取充值前金额进行数据校验 if case.check_sql: # 将sql语句参数化 sql = Parameterize.to_parameter(case.check_sql) # 执行查询语句,在数据库中查询得到数据字典 res_dict = self.do_mysql.run(sql, is_more=False) # 取得充值前账户金额,转换为float # global amount_before amount_before = float(res_dict['leave_amount']) # 保留2位小数 amount_before = round(amount_before, 2) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) # 如果充值成功,则获取充值成功后的金额(反向用例没有做数据校验) if case.check_sql: # # 将sql语句参数化 # sql = Parameterize.to_parameter(case.check_sql) # 在数据库中查询得到数据字典 res_dict = self.do_mysql.run(sql, is_more=False) # 取得充值后账户金额,取2位 amount_after = round(float(res_dict['leave_amount']), 2) # 进行断言 amount_real = json.loads(new_data) self.assertEqual(round((amount_after - amount_before), 2), amount_real.get('amount')) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} self.do_request.add_headers(token_headers) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_invest(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, method=case.method, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # 获取标ID # # 获取token # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) # 也可以使用成员运算:if 'token' in res.text: if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} self.do_request.add_headers(token_headers) # 获取loan_id (更方便的是直接从响应报文中获取loan_id) case_sql = case.case_sql if case_sql: # 也可以使用成员运算来判断 if 'loan_id_sql' in case_sql: case_sql = json.loads(case_sql, encoding='utf8').get('loan_id_sql') # 借款人ID参数化 case_sql = Parameterize.to_parameter(case_sql) # 查询数据库中该借款人对应的最新的loan_id loan_id_dict = self.do_mysql.run(case_sql, is_more=False) # 从结果字典中取loan_id loan_id = loan_id_dict.get('id') # 反射机制动态设置类属性,然后进行参数化,使得之后的用例可以取得loan_id(接口依赖) setattr(Parameterize, 'loan_id', loan_id) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_invest(self, case): #参数化 new_data = Parameterize.to_param(case.data) #构造请求URL new_url = do_yaml.read("api", "profix") + case.url res = self.do_request.send(url=new_url, method=case.method, data=new_data) #将响应报文转化为字典类型 actul_value = res.json() #获取测试用例所在的行 row = case.case_id + 1 #获取预期结果 expected_result = case.expected #获取测试用例标题 msg = case.title # 获取用例执行成功的提示 success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行失败的提示 fail_msg = do_yaml.read('msg', 'fail_result') try: self.assertEqual(actul_value.get("code"), expected_result, msg=msg) # check_sql = case.check_sql # if check_sql: # check_sql = Parameterize.to_param(case.check_sql) # mysql_data = self.do_mysql.run(sql=check_sql) # loan_id = mysql_data["id"] # setattr(Parameterize, "loan_id", loan_id) except Exception as e: # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: if "token_info" in res.text: token = actul_value["data"]["token_info"]["token"] header = {"Authorization": "Bearer " + token} self.do_request.add_headers(header) # 获取表的编号 check_sql = case.check_sql if check_sql: check_sql = Parameterize.to_param(case.check_sql) mysql_data = self.do_mysql.run(sql=check_sql) loan_id = mysql_data["id"] setattr(Parameterize, "loan_id", loan_id) # 取出load id的第二种方法 # if case.case_id == 2: # load_id = actual_value["data"]["id"] # setattr(Parameterize, 'loan_id', load_id) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") finally: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text)
def test_recharge(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # # 获取token # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = { 'Authorization': 'Bearer ' + actual_value['data']['token_info']['token'] } self.do_request.add_headers(token_headers) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_register(self, case): # 参数化 new_data = Parameterize.to_param(case.data) # 构造url new_url = do_yaml.read("api", "profix") + case.url # 向服务器发起请求 res = self.do_request.send( url=new_url, # url地址 # method=case.method, # 请求方法 data=new_data # 请求参数 # is_json=True # 是否以json格式来传递数据, 默认为True ) #将响应报文转化为json actual_value = res.json() # 获取测试用例行号 row = case.case_id + 1 #获取预期结果 expected_result = case.expected # 获取测试用例的标题 msg = case.title #获取用例成功与失败的提示 success_msg = do_yaml.read('msg', 'success_result') fail_msg = do_yaml.read('msg', 'fail_result') try: self.assertEqual(expected_result, actual_value.get('code'), msg=msg) except Exception as e: # # # 将相应实际值写入到actual_col列 # self.excel.write_data(row = row, # column = do_yaml.read("excel","actual_col"), # value = res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # error 指的时日志的收集等级 do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: # # # 将相应实际值写入到actual_col列 # self.excel.write_data(row = row, # column = do_yaml.read("excel","actual_col"), # value = res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) # info 指的时日志的收集等级 do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") finally: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text)
def test_recharge(self, case): # 参数化 new_data = Parameterize.to_param(case.data) # 构造请求url new_url = do_yaml.read("api", "profix") + case.url check_sql = case.check_sql # 判断check_sql字段是否为空(非空即为True) if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验 #参数化check_sql check_sql = Parameterize.to_param(case.check_sql) #执行sql获取充值前金额 mysql_data = self.do_mysql.run(check_sql) # 不是float类型, 也不是int类型, 是decimal类型 amount_before = float(mysql_data["leave_amount"]) # 由于使用float转化之后的数, 有可能小数位数超过2位, 需要使用round保留2位小数 amount_before = round(amount_before, 2) #发起请求 res = self.do_request.send(url=new_url, data=new_data) # 将相应报文中的数据转化为字典 actual_value = res.json() #获取测试用例的行 row = case.case_id + 1 #获取预期结果 expected_result = case.expected # 获取测试用例的标题 msg = case.title success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示 fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示 try: self.assertEqual(actual_value.get("code"), expected_result, msg=msg) if check_sql: check_sql = Parameterize.to_param(check_sql) mysql_data = self.do_mysql.run(sql=check_sql) amount_after = float(mysql_data["leave_amount"]) amount_after = round(amount_after, 2) #从data中取出充值金额 data = json.loads(new_data, encoding="utf8") # 充值金额 current_recharge_amount = data["amount"] #充值后金额 actual_amount = round(amount_before + current_recharge_amount, 2) self.assertEqual(amount_after, actual_amount, msg="数据库中的金额有误") except Exception as e: # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # error 指的时日志的收集等级 do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: if "token_info" in res.text: token = actual_value["data"]["token_info"]["token"] header = {"Authorization": "Bearer " + token} self.do_request.add_headers(header) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) # info 指的时日志的收集等级 do_log.info(f"{msg}, 执行的结果为: {success_msg}\n") finally: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text)
self.assertEqual(expected_result.get('msg'), actual_value.get('msg'), msg=msg) except AssertionError as e: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # do_log.error("断言异常: {}".format(e)) do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: if "token" in res.text: token = actual_value.get('data')['token'] # 获取token信息 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) if case.case_id == 2: companyId = actual_value.get('data')['companyId'] setattr(Parameterize, 'companyId', companyId) # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row,
def test_recharge(self, case): # 将期望结果取出 expected = case.expected # 参数化,将取出来的字符串进行参数替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 判断用例种sql语句是否存在,存在的时候去做金额的查询(在充值之前) check_sql = case.check_sql # 如果SQL不为空,则进行参数替换,并且获取当前金额 if check_sql: check_sql = HandleParam.to_param(check_sql) mysql_data = self.do_mysql.run(check_sql) old_amount = round(float(mysql_data['leave_amount']), 2) # 不是float和int,是decimal类型 # 向接口发起请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str) # 获取的报文转换为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected, result['code'], msg=msg) # 充值成功之后进行金额数值的校验 if check_sql: # 去数据库取充值后的金额 new_amount = round( float(self.do_mysql.run(check_sql)['leave_amount']), 2) # new_amount = result['data']['leave_amount'] recharge_amount = json.loads(data_str)['amount'] actual_amount = round(new_amount - old_amount, 2) self.assertEqual(recharge_amount, actual_amount, msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if result.get('data'): if result.get('data').get('token_info'): self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def test_recharge(self, case): # 1. 参数化 new_data = Parameterize.to_param(case.data) # 2. 拼接完整的url new_url = do_yaml.read('api', 'prefix') + case.url check_sql = case.check_sql # 取出check_sql if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验 check_sql = Parameterize.to_param(check_sql) # 将check_sql进行参数化 mysql_data = self.do_mysql.run(check_sql) # 执行sql amount_before = float(mysql_data['leave_amount']) # 不是float类型, 也不是int类型, 是decimal类型 # 由于使用float转化之后的数, 有可能小数位数超过2位, 需要使用round保留2位小数 amount_before = round(amount_before, 2) # 3. 向服务器发起请求 # 进行充值 res = self.do_request.send(url=new_url, # url地址 # method=case.method, # 请求方法 data=new_data, # 请求参数 # is_json=True # 是否以json格式来传递数据, 默认为True ) # 将相应报文中的数据转化为字典 actual_value = res.json() # 获取用例的行号 row = case.case_id + 1 # 将expected期望值转化为字典 expected_result = case.expected msg = case.title # 获取标题 success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示 fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示 try: self.assertEqual(expected_result, actual_value.get('code'), msg=msg) # 如果check_sql不为空, 说明要进行数据校验 if check_sql: mysql_data = self.do_mysql.run(sql=check_sql) amount_after = float(mysql_data['leave_amount']) # 不是float浮点数, 更不是int类型, 而是decimal数据类型 amount_after = round(amount_after, 2) one_dict = json.loads(new_data, encoding='utf-8') currrent_recharge_amount = one_dict['amount'] actual_amount = round(amount_before + currrent_recharge_amount, 2) self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误") except AssertionError as e: # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=fail_msg) # do_log.error("断言异常: {}".format(e)) do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n") raise e else: # 如果登录接口断言成功, 则取出token, 并添加到公共请求头中 if 'token_info' in res.text: token = actual_value['data']['token_info']['token'] headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # 将相应实际值写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read("excel", "actual_col"), value=res.text) # 将用例执行结果写入到result_col self.excel.write_data(row=row, column=do_yaml.read("excel", "result_col"), value=success_msg) do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")