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, item):
case_id = item["case_id"]
title = item["title"]
url = cf.get_value(conf_env, "prefix_url") + item["url"]
method = item["method"]
expected = item["expected"]
data = item["data"]
new_data = Context.recharge_parameterization(data) # 将数据中进行参数替换
check_sql = item["check_sql"]
if check_sql:
new_sql = Context.recharge_parameterization(check_sql)
result = self.handler_mysql.select(new_sql)
amount_before = float(result["LeaveAmount"])
amount_before = round(amount_before, 2)
msg = "测试" + title
success_msg = cf.get_value("case", "success")
fail_msg = cf.get_value("case", "fail")
ret = self.request.send_request(method, url, new_data)
try:
self.assertIn(str(expected), ret.text, msg)
# 校验充值金额
data_dict = json.loads(data)
recharge_amount = data_dict.get("amount")
if check_sql:
result = self.handler_mysql.select(new_sql)
amount_after = float(result["LeaveAmount"])
amount_after = round(amount_after, 2)
self.assertEqual(round(amount_after - amount_before, 2),
recharge_amount, "数据库充值金额校验失败")
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
success_msg)
logger.debug("{}, 执行结果为:{}".format(msg, success_msg))
except AssertionError as e:
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
fail_msg)
logger.error("{}, 执行结果为:{}, 异常结果为:{}".format(msg, fail_msg, e))
raise e
def test_register(self, item):
case_id = item["case_id"]
title = item["title"]
url = cf.get_value(conf_env, "prefix_url") + item["url"]
method = item["method"]
expected = item["expected"]
data = item["data"]
new_data = Context.register_parameterization(data) # 将数据中进行参数替换
msg = "测试" + title
success_msg = cf.get_value("case", "success")
fail_msg = cf.get_value("case", "fail")
ret = self.request.send_request(method, url, new_data)
try:
self.assertEqual(ret.text, expected, msg)
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
success_msg)
logger.debug("{}, 执行结果为:{}".format(msg, success_msg))
except AssertionError as e:
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
fail_msg)
logger.error("{}, 执行结果为:{}, 异常结果为:{}".format(msg, fail_msg, e))
raise e
def test_add(self,one_case):
# data = one_case['data'] #需要进行参数化
new_data = Context.admin_user_tel_pwd_replace(one_case['data']) #需要实现
new_url = do_config.get_value('api', 'prefix_url') + one_case['url']
#向服务器发起请求
res = self.do_request.to_request(method=one_case['method'],
url=new_url,
data=new_data)
#期望值
expect_result = one_case['expected']
msg = "测试" + one_case['title']
success_msg = do_config.get_value('msg', 'success_result')
fail_msg = do_config.get_value('msg', 'fail_result')
case_id = one_case['case_id']
try:
# self.assertEqual(str(expect_result), code, msg=msg)
self.assertIn(str(expect_result), res.text, msg=msg)
do_excel.write_result(case_id+1, res.text, success_msg)
do_logger.debug('{},执行结果为：{}'.format(msg, success_msg))
except AssertionError as e:
do_excel.write_result(case_id+1, res.text, fail_msg)
do_logger.error('{}, 执行结果为：{}具体异常为：{}'.format(msg, fail_msg, e))
raise e
def test_recharge(self, one_case):
# data = one_case['data'] #需要进行参数化
new_data = Context.recharge_parameterization(one_case['data']) #需要实现
new_url = do_config.get_value('api', 'prefix_url') + one_case['url']
check_sql = one_case['check_sql']
if check_sql:
check_sql = Context.recharge_parameterization(check_sql)
mysql_data = self.handle_mysql.to_run(
check_sql) #decimal.Decimal类型
amount_before_recharge = float(mysql_data['LeaveAmount'])
amount_before_recharge = round(amount_before_recharge, 2)
dict_data = json.loads(new_data, encoding='utf-8')
recharge_number = dict_data['amount']
#向服务器发起请求
res = self.do_request.to_request(method=one_case['method'],
url=new_url,
data=new_data)
#期望值
expect_result = one_case['expected']
msg = "测试" + one_case['title']
success_msg = do_config.get_value('msg', 'success_result')
fail_msg = do_config.get_value('msg', 'fail_result')
case_id = one_case['case_id']
code = res.json().get('code')
try:
self.assertEqual(str(expect_result), code, msg=msg)
# self.assertIn(str(expect_result), res.text, msg=msg)
if check_sql:
mysql_data = self.handle_mysql.to_run(
check_sql) # decimal.Decimal类型
amount_after_recharge = float(mysql_data['LeaveAmount'])
amount_after_recharge = round(amount_after_recharge, 2)
self.assertEqual(
recharge_number,
(amount_after_recharge - amount_before_recharge),
msg=msg)
do_excel.write_result(case_id + 1, res.text, success_msg)
do_logger.debug('{},执行结果为：{}'.format(msg, success_msg))
except AssertionError as e:
do_excel.write_result(case_id + 1, res.text, fail_msg)
do_logger.error('{}, 执行结果为：{}具体异常为：{}'.format(msg, fail_msg, e))
raise e
def test_invest(self, one_case):
# data = one_case['data'] #需要进行参数化
# print(data)
# print(type(data))
new_data = Context.invest_parameterization(one_case['data']) #需要实现
print('-----------------')
print(new_data)
print('&&&&&&&&&&&&&&&&&&&')
new_url = do_config.get_value('api', 'prefix_url') + one_case['url']
#向服务器发起请求
res = self.do_request.to_request(method=one_case['method'],
url=new_url,
data=new_data)
if '加标成功' in res.text:
check_sql = one_case['check_sql']
if check_sql:
check_sql = Context.invest_parameterization(check_sql)
print(check_sql)
mysql_data = self.handle_mysql.to_run(check_sql)
print(mysql_data, type(mysql_data))
#动态修改或者获取变量的一个过程
# Context.loan_id = mysql_data.get('Id') #类属性
setattr(Context, "loan_id", mysql_data['Id'])
print('-----动态----', getattr(Context, "loan_id"))
#期望值
expect_result = one_case['expected']
msg = "测试" + one_case['title']
success_msg = do_config.get_value('msg', 'success_result')
fail_msg = do_config.get_value('msg', 'fail_result')
case_id = one_case['case_id']
try:
# self.assertEqual(str(expect_result), code, msg=msg)
self.assertIn(str(expect_result), res.text, msg=msg)
do_excel.write_result(case_id + 1, res.text, success_msg)
do_logger.debug('{},执行结果为：{}'.format(msg, success_msg))
except AssertionError as e:
do_excel.write_result(case_id + 1, res.text, fail_msg)
do_logger.error('{}, 执行结果为：{}具体异常为：{}'.format(msg, fail_msg, e))
raise e
def test_invest(self, item):
case_id = item["case_id"]
title = item["title"]
url = cf.get_value(conf_env, "prefix_url") + item["url"]
method = item["method"]
expected = item["expected"]
data = item["data"]
new_data = Context.invest_parameterization(data) # 将数据中进行参数替换
check_sql = item["check_sql"]
if check_sql:
new_sql = Context.invest_parameterization(check_sql)
result = self.handler_mysql.select(new_sql)
loan_id = result.get("id")
setattr(Context, "loan_id", loan_id)
msg = "测试" + title
success_msg = cf.get_value("case", "success")
fail_msg = cf.get_value("case", "fail")
ret = self.request.send_request(method, url, new_data)
try:
self.assertIn(str(expected), ret.text, msg)
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
success_msg)
logger.debug("{}, 执行结果为:{}".format(msg, success_msg))
except AssertionError as e:
do_excel.write_value(case_id + 1, cf.get_int("case", "actual_col"),
ret.text)
do_excel.write_value(case_id + 1, cf.get_int("case", "result_col"),
fail_msg)
logger.error("{}, 执行结果为:{}, 异常结果为:{}".format(msg, fail_msg, e))
raise e
def test_add_event(self, one_case):
base_url = do_config.get_config("address", "add_address")
payload = Context().readd_parameterization_id(one_case["data"])
self.res = (self.one_session.to_request(base_url,
data=payload,
method='post')).json()
expected_results = json.loads(one_case["expected"]) #预期结果
msg = one_case['title']
try:
self.assertEqual(expected_results, self.res)
do_excel.write_result(one_case['case_id'] + 1, self.res['message'],
"Pass")
do_log.info("test_add_event:{} ,测试结果为 {}".format(msg, "Pass"))
except AssertionError as e:
do_excel.write_result(one_case['case_id'] + 1, self.res['message'],
"Fail")
do_log.info("test_add_event:{} ,测试结果为 {}".format(msg, "Fail"))
raise e
def test_UnRegister(self, case):
print(case)
Logging.info("测试用例名称为：{}".format(case["title"]))
register_params = Context.register_parameterization(case["data"])
is_success, response = TestUnRegister.request.request(
case["url"], case["method_name"], eval(register_params))
if is_success:
case["actual"] = response["retCode"]
case["result"] = str(response)
TestUnRegister.case_list.append(case)
Logging.info("response：{}".format(str(response)))
try:
self.assertEqual(int(case["expected"]),
int(response["retCode"]))
# 请求数据库
check_sql = case["check_sql"]
if check_sql:
check_sql = Context.register_parameterization(check_sql)
print("第2 = " + check_sql)
handle_sql = HandleMySql()
mysql_data = handle_sql.get_value(check_sql)
print(mysql_data)
print(type(mysql_data))
verify_code = mysql_data["Fverify_code"]
setattr(Context, "verify_code", str(verify_code))
handle_sql.close()
except AssertionError as e:
Logging.info("具体异常为：{}".format(e))
raise e
else:
if isinstance(response, WebFault):
case["actual"] = response.fault.faultcode # 错误代码
case["result"] = response.fault.faultstring # 错误描述
TestUnRegister.case_list.append(case)
Logging.info("response：{}".format(str(response.fault)))
try:
self.assertEqual(str(case["expected"]),
response.fault.faultcode)
except AssertionError as e:
Logging.info("具体异常为：{}".format(e))
raise e
def test_login(self, one_case):
new_data = Context.register_parameterization(one_case['data'])
new_url = do_config.get_value('api', 'prefix_url') + one_case['url']
#向服务器发起请求
res = TestLogin.do_request.to_request(method=one_case['method'],
url=new_url,
data=new_data)
#期望值
expected_result = one_case['expected']
msg = "测试" + one_case['title']
success_msg = do_config.get_value('msg', 'success_result')
fail_msg = do_config.get_value('msg', 'fail_result')
case_id = one_case['case_id']
try:
self.assertEqual(expected_result, res.text, msg=msg)
do_excel.write_result(case_id + 1, res.text, success_msg)
do_logger.debug('{},执行结果为：{}'.format(msg, success_msg))
except AssertionError as e:
do_excel.write_result(case_id + 1, res.text, fail_msg)
do_logger.error('{}, 执行结果：{}具体异常为：{}'.format(msg, fail_msg, e))
raise e