class TestRecharge(unittest.TestCase):
@classmethod
def setUpClass(cls):
do_logger.info('\n{:=^40s}\n'.format('开始执行用例'))
@classmethod
def tearDownClass(cls):
do_logger.info('\n{:=^40s}\n'.format('用例执行结束'))
def setUp(self):
pass
def tearDown(self):
wb, ws = self.my_HandleExcel.load_excel()
wb.save(DATA_COMMON_FILE_PATH)
wb.close()
do_request.request_close()
@data(*cases_suite)
def test_recharge(self, case_list):
self.my_HandleExcel = HandleExcel(DATA_COMMON_FILE_PATH, 'recharge')
if case_list['check_sql']:
before_sql_data = do_mysql.sql_search(
case_list['check_sql'],
virtue=eval(case_list['data'])['mobilephone'])
self.before_leaveamount = float(before_sql_data['LeaveAmount'])
request_result = do_request.send_request(
case_list['method'],
do_config.get_value('request', 'default_address') +
case_list['url_path'], case_list['data'])
actual = int(request_result.json().get('code'))
result = case_list['expected']
msg = case_list['title']
try:
self.assertEqual(result, actual, msg)
if case_list['check_sql']:
after_sql_data = do_mysql.sql_search(
case_list['check_sql'],
virtue=eval(case_list['data'])['mobilephone'])
after_leaveamount = float(after_sql_data['LeaveAmount'])
true_results = after_leaveamount - self.before_leaveamount
self.assertEqual(
eval(case_list['data'])['amount'], round(true_results, 2),
msg)
print('{},执行结果为:{}'.format(msg, true_result))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
true_result)
do_logger.error("{}, 执行结果为: {}".format(msg, true_result))
except AssertionError as e:
print('具体异常为{}'.format(e))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
fail_result)
do_logger.error("{}, 执行结果为: {},具体异常为{}".format(
msg, fail_result, e))
raise e
def excel_suite():
not_existed_tel = do_mysql.not_existed_tel()
register_excel = HandleExcel(DATA_COMMON_FILE_PATH, 'login')
register_excel_cases = register_excel.get_cases()
register_excel_re = re.sub(r'\${not_existed_tel}', not_existed_tel, str(register_excel_cases))
existed_tel = do_mysql.existed_tel()
register_cases = re.sub(r'\${existed_tel}', existed_tel, str(register_excel_re))
register_cases = eval(register_cases)
wb, ws = register_excel.load_excel()
wb.close()
return register_cases
def excel_suite():
register_excel = HandleExcel(DATA_COMMON_FILE_PATH, 'recharge') # 实例化对象
register_excel_cases = register_excel.get_cases() # 获取excel测试用例
register_cases = HandleContext.not_existed_tel(
HandleContext.investors_user_pwd(
HandleContext.investors_user_tel(
str(register_excel_cases)))) # 执行参数化替换
register_cases = eval(register_cases)
wb, ws = register_excel.load_excel()
wb.close()
return register_cases
def excel_suite():
register_excel = HandleExcel(DATA_COMMON_FILE_PATH, 'add') # 实例化对象
register_excel_cases = register_excel.get_cases() # 获取excel测试用例
register_cases = HandleContext.borrower_user_id(
HandleContext.manager_user_pwd(
HandleContext.manager_user_tel(
str(register_excel_cases)))) # 执行参数化替换
register_cases = eval(register_cases)
wb, ws = register_excel.load_excel()
wb.close()
return register_cases
class TestLogin:
obj_li = HandleExcel('login')
cases = obj_li.read_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequests()
# cls.hm = HandleMysql()
# cls.hr.common_heads({hy.read_yaml('request', 'request_head'): hy.read_yaml('request', 'request_value')})
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize('case', cases)
def test_login(self, set_up, case):
url = hy.read_yaml('request', 'base_url') + case.url
if case.caseId == 2:
HandlePhone.phone_yaml()
data = HandleRe.handle_para(case.data)
res = set_up[0].send(url=url, data=data)
try:
self.obj_li.write_excel(int(case.caseId) + 1,
8,
value=str(res.json()))
assert [case.expected,
case.msg] == [res.json()['code'],
res.json()['msg']]
except AssertionError as e:
my_logger.error(f'用例{case.title}断言失败')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='fail')
raise e
else:
my_logger.info(f'用例{case.title}断言成功')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='success')
class TestCompany(unittest.TestCase):
"""
测试公司信息
"""
excel = HandleExcel("company")
cases = excel.read_data_obj()
s = handle_yaml.do_yaml
@classmethod
def setUpClass(cls):
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.read('api',
'version')) # 添加公共的请求头, url版本号
@classmethod
def tearDownClass(cls):
cls.do_request.close()
@data(*cases)
def test_company(self, case):
# 1. 参数化
new_data = Parameterize.to_param(case.data)
# 2. 拼接完整的url
if case.case_id > 3:
new_url = do_yaml.read(
'api', 'prefix') + case.url + '/' + r'{invest_companyId}'
else:
class TestCaseRegister(unittest.TestCase):
excel = HandleExcel('register')
cases = excel.read_data()
@data(*cases)
def test_case_method(self, case):
# 获取测试用例行号
row = case.case_id + 1
# 第一步 准备测试用例数据
expected = eval(case.expected)
data1 = eval(case.data)
# 第二步 调用功能函数 获取实际结果
res = register(*data1)
# 第三步 比对预期结果和实际结果
try:
self.assertEqual(res, expected)
except AssertionError as e:
log.info('用例{}执行未通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=do_yaml.read('msg', 'fail_result'))
log.error(f"断言异常:{e}")
raise e
else:
log.info('用例{}执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=do_yaml.read('msg', 'success_result'))
class TestProduct(unittest.TestCase):
"""
测试产品功能
"""
excel = HandleExcel("supplier")
cases = excel.read_data_obj()
s = handle_yaml.do_yaml
@classmethod
def setUpClass(cls):
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.read('api',
'version')) # 添加公共的请求头, url版本号
@classmethod
def tearDownClass(cls):
cls.do_request.close()
@data(*cases)
def test_product(self, case):
# 1. 参数化
new_data = Parameterize.to_param(case.data)
# 2. 拼接完整的url
if case.case_id == 4:
mysql = HandleMysql()
ss = mysql.run(do_yaml.read('mysql', 'select_product_id'))
new_url = do_yaml.read('api', 'prefix') + case.url + ss['id']
mysql.close()
else:
class CaseSend(unittest.TestCase):
"""
发送验证码用例
"""
do_log = HandleLogging().get_logger()
do_excel = HandleExcel(TEST_DATAS_FILE_PATH2, sheetname='sendMCode')
case_list = do_excel.get_cases()
@classmethod
def setUpClass(cls):
cls.do_log.info("\n{:=^40}".format("开始执行用例"))
cls.send_request = HandleSuds()
@classmethod
def tearDownClass(cls):
cls.do_log.info("\n{:=^40}".format("用例执行结束"))
@data(*case_list)
def test_sendMCode(self, one_case):
self.do_log.info("\nRunning Testing Methon:{}".format(inspect.stack()[0][3]))
new_data = Context.sendmcode_parameterization(one_case.data)
res = self.send_request(url=one_case.url, api=one_case.api, data=new_data)
actual_result = str(res)
expect_result = one_case.expected
try:
self.assertEqual(expect_result, actual_result, msg="测试{}失败".format(one_case.title))
except AssertionError as e:
self.do_log.error("具体异常为：{}".format(e))
self.do_excel.write_result(row=one_case.case_id + 1, actual=str(res), result='Fail')
raise e
else:
self.do_excel.write_result(row=one_case.case_id + 1, actual=str(res), result='pass')
class TestInvest:
obj_li = HandleExcel('invest')
cases = obj_li.read_excel()
@pytest.mark.parametrize('case', cases)
def test_invest(self, set_up, case):
url = hy.read_yaml('request', 'base_url') + case.url
data = HandleRe.handle_para(case.data)
res = set_up[0].send(url=url, data=data)
if case.caseId == 2:
invest_token = res.json()['data']['token_info']['token']
set_up[0].common_heads({'Authorization': 'Bearer ' + invest_token})
try:
self.obj_li.write_excel(int(case.caseId) + 1,
8,
value=str(res.json()))
assert [case.expected,
case.msg] == [res.json()['code'],
res.json()['msg']]
except AssertionError as e:
my_logger.error(f'用例{case.title}断言失败')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='fail')
raise e
else:
my_logger.info(f'用例{case.title}断言成功')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='success')
class TestCaseLogin(unittest.TestCase):
do_request = HandleRequest()
do_config = HandleConfig(CONFIG_REQUEST)
do_excel = HandleExcel(DATA_CASES, 'login')
cases = do_excel.get_cases()
do_log = HandleLog
do_re = Handle_Re
pass_result = do_config.get_value('result', 'pass_result')
fail_result = do_config.get_value('result', 'fail_result')
@classmethod
def setUpClass(cls):
cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8')
cls.one_file.write('{:=^40s}\n'.format('开始执行登录接口用例'))
@classmethod
def tearDownClass(cls):
cls.one_file.write('{:=^40s}\n\n'.format('登录接口用例执行结束'))
cls.one_file.close()
@data(*cases)
def test_login(self, one_case):
# 拼接完整的url
new_url = self.do_config.get_value('url', 'head_url') + one_case['url']
# 获取请求方式
method = one_case['method']
# 获取input_data数据
# input_data = one_case['input_data']
# 对excel的input_data数据进行参数化
new_data = self.do_re.login_parameterization(one_case['input_data'])
# 发送请求接收请求后的结果
result_real = self.do_request.send_request(url=new_url,
data=eval(new_data),
method=method).text
try:
self.assertIn(one_case['expected'], result_real, msg='登录接口请求成功')
self.one_file.write('{},执行的结果为:{}\n'.format(
one_case['title'], self.pass_result))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.pass_result)
except AssertionError as err:
self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format(
one_case['title'], self.fail_result, err))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.fail_result)
raise err
self.do_request.close_request()
class TestRegister(unittest.TestCase):
# read = HandleExcel(os.path.join(DATAS_DIR, do_yaml.read_yaml('excel', 'cases_path')), 'register')
# 可以在模块中直接写好文件路径，这里只传表单名就可
excel = HandleExcel('register')
cases = excel.read_data_obj()
@classmethod
def setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
@classmethod
def tearDownClass(cls):
cls.do_request.close()
@data(*cases)
def test_register(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)
finally:
# 将响应实际结果写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
class TestRegister(unittest.TestCase):
# 创建handleexcel对象
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "register")
testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表
@classmethod
def setUpClass(cls):
# 构造请求参数
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.get_data(
"api", "api_version")) # 添加请求头到公共请求头
cls.do_mysql = HandleMysql() # 创建HandleMysql对象
# cls.do_mysql.create_not_existed_mobile()
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
# 释放资源
cls.do_request.close()
cls.do_mysql.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_register(self, one_testcase):
# 在每条用例执行之前，获取未注册的手机号码，然后更新全局数据池
setattr(GlobalData, "${not_existed_tel}",
self.do_mysql.create_not_existed_mobile())
# 将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)
# 获取接口返回数据中的code值
real_code = res.json()["code"]
# row = testcase_dict["id"] + 1
# self.do_excel.write_data(row, 7, res.text)
# name = testcase_dict["name"]
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value, real_code,
one_testcase.name)
except AssertionError as e:
# print("此处需要使用日志器来记录日志！")
# my_logger.error(f"{one_testcase.name}：具体异常为{e}")
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# print(f"具体异常为：{e}")
# self.do_excel.write_data(row, 8, "失败")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# self.do_excel.write_data(row, 8, "成功")
# do_log.debug(res.text)
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "成功")
def setUpClass(cls):
setattr(Context, "db_name", "user_db")
cls.request = WebServiceRequests()
cls.my_excel = HandleExcel()
cls.handle_sql = HandleMySql()
cls.my_excel.get_exist_excel(
os.path.join(RESULT_EXCEL_FILE_PATH, "my_result.xlsx"))
cls.case_list = []
class TestRegister(unittest.TestCase):
handleExcel = HandleExcel(DATA_CASES, 'register')
cases = handleExcel.get_cases()
do_config = HandleConfig(CONFIG_REQUEST)
head_url = do_config.get_value('url', 'head_url')
do_request = HandleRequest()
# 用例执行通过信息
pass_result = do_config.get_value('result', 'pass_result')
# 用例执行不通过信息
fail_result = do_config.get_value('result', 'fail_result')
do_re = Handle_Re()
@classmethod
def setUpClass(cls):
cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8')
cls.one_file.write('{:=^40s}\n'.format('开始执行注册接口用例'))
@classmethod
def tearDownClass(cls):
cls.one_file.write('{:=^40s}\n\n'.format('注册接口用例执行结束'))
cls.one_file.close()
@data(*cases)
def test_register(self, one_case):
# 注册接口的url
new_url = self.head_url + one_case['url']
# 对用例中的数据进行参数化
new_data = self.do_re.register_parameterization(one_case['input_data'])
method = one_case['method']
# 发送注册接口的请求
result_real = self.do_request.send_request(url=new_url,
data=eval(new_data),
method=method).text
try:
self.assertIn(one_case['expected'], result_real, msg='注册接口请求成功')
self.one_file.write('{},执行的结果为:{}\n'.format(
one_case['title'], self.pass_result))
self.handleExcel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.pass_result)
except AssertionError as err:
self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format(
one_case['title'], self.fail_result, err))
self.handleExcel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.fail_result)
raise err
self.do_request.close_request()
class TestRecharge:
he = HandleExcel('recharge')
list_obj = he.operate_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequest()
# cls.hm = HandleMysql()
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize('obj', list_obj)
def test_recharge(self, set_up, obj):
url = hy.read_yaml('excel', 'base_url') + obj.url
request_data = HandleRe.get_data(data=obj.data)
result_sql = obj.sql
invest_phone = set_up[2].read_yaml("investor", 'mobile_phone')
if result_sql:
mysql_result = set_up[1].get_mysql_result(sql=result_sql,
args=invest_phone)
if mysql_result[0]:
before_amount = float(mysql_result[0])
else:
before_amount = 0
result = set_up[0].send(url=url, data=request_data)
if obj.caseId == 2:
login_token = result.json()['data']['token_info']['token']
set_up[0].common_head({"Authorization": "Bearer " + login_token})
try:
assert [obj.expected,
obj.msg] == [result.json()['code'],
result.json()['msg']]
if result_sql:
mysql_result = set_up[1].get_mysql_result(sql=result_sql,
args=invest_phone)
if mysql_result:
after_amount = float(mysql_result[0])
recharge_value = float(
result.json()['data']['leave_amount'])
assert after_amount - before_amount == recharge_value
except AssertionError as e:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='fail')
logger.error(e)
raise e
else:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='success')
logger.info(f"用例{obj.title}执行通过")
finally:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=8,
sheet_value=result.text)
class TestRegister(unittest.TestCase):
@classmethod
def setUpClass(cls):
do_logger.info('\n{:=^40s}\n'.format('开始执行用例'))
@classmethod
def tearDownClass(cls):
do_logger.info('\n{:=^40s}\n'.format('用例执行结束'))
def setUp(self):
pass
def tearDown(self):
wb, ws = self.my_HandleExcel.load_excel()
wb.save(DATA_COMMON_FILE_PATH)
wb.close()
@data(*cases_suite)
def test_register(self, case_list):
self.my_HandleExcel = HandleExcel(DATA_COMMON_FILE_PATH, 'register')
request_result = do_request.send_request(
case_list['method'],
do_config.get_value('request', 'default_address') +
case_list['url_path'], case_list['data'])
actual_text = request_result.text
actual_value = json.loads(actual_text)['code']
actual = 'code: "{}",'.format(actual_value)
result = case_list['expected']
msg = case_list['title']
try:
self.assertEqual(result, actual, msg)
print('{},执行结果为:{}'.format(msg, true_result))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
true_result)
do_logger.error("{}, 执行结果为: {}".format(msg, true_result))
except AssertionError as e:
print('具体异常为{}'.format(e))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
fail_result)
do_logger.error("{}, 执行结果为: {},具体异常为{}".format(
msg, fail_result, e))
raise e
def test_login(self, case_list):
self.my_HandleExcel = HandleExcel(DATA_COMMON_FILE_PATH, 'login')
request_result = do_request.send_request(case_list['method'],
do_config.get_value('request', 'default_address') + case_list[
'url_path'],
case_list['data'])
actual_text = request_result.text
actual_value = json.loads(actual_text)['code']
actual = 'code: "{}",'.format(actual_value)
result = case_list['expected']
msg = case_list['title']
try:
self.assertEqual(result, actual, msg)
print('{},执行结果为:{}'.format(msg, true_result))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual, true_result)
do_logger.error("{}, 执行结果为: {}".format(msg, true_result))
except AssertionError as e:
print('具体异常为{}'.format(e))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual, fail_result)
do_logger.error("{}, 执行结果为: {},具体异常为{}".format(msg, fail_result, e))
raise e
class TestLogin(unittest.TestCase):
# 创建handleexcel对象
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "login")
testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表
@classmethod
def setUpClass(cls):
# 构造请求参数
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.get_data(
"api", "api_version")) # 添加请求头到公共请求头
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
# 释放资源
cls.do_request.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_login(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()
# 将expected_value期望值转化为字典类型
expect_result = json.loads(one_testcase.expected_value,
encoding='utf-8')
try:
# self.assertIn(one_testcase.expected_value,
# res.text,
# one_testcase.name)
# 断言： 预期结果==实际结果，断言结果
self.assertEqual(expect_result.get('code'),
actual_value.get('code'), one_testcase.name)
self.assertEqual(expect_result.get('msg'), actual_value.get('msg'),
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:
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRecharge:
obj_li = HandleExcel('recharge')
cases = obj_li.read_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequests()
# cls.hm = HandleMysql()
# cls.hl = HandleYaml(PHONE_PATH)
# cls.hr.common_heads({hy.read_yaml('request', 'request_head'): hy.read_yaml('request', 'request_value')})
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize("case", cases)
def test_recharge(self, set_up, case):
url = hy.read_yaml('request', 'base_url') + case.url
data = HandleRe.handle_para(case.data)
invest_phone = set_up[2].read_yaml('investor', 'mobile_phone')
before_send_amount = 0
if case.sql:
phone_result = set_up[1].get_mysql_result(case.sql,
arg=invest_phone)
if phone_result['amount']:
before_send_amount = float(phone_result['amount'])
res = set_up[0].send(url=url, data=data)
if case.caseId == 2:
invest_token = res.json()['data']['token_info']['token']
set_up[0].common_heads({'Authorization': 'Bearer ' + invest_token})
try:
self.obj_li.write_excel(int(case.caseId) + 1,
8,
value=str(res.json()))
if case.sql:
after_send_amount = float(set_up[1].get_mysql_result(
case.sql, arg=invest_phone)['amount'])
amount_num = round((after_send_amount - before_send_amount), 2)
assert amount_num == eval(case.data)['amount']
assert [case.expected,
case.msg] == [res.json()['code'],
res.json()['msg']]
except AssertionError as e:
my_logger.error(f'用例{case.title}断言失败')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='fail')
raise e
else:
my_logger.info(f'用例{case.title}断言成功')
self.obj_li.write_excel(int(case.caseId) + 1, 7, value='success')
class TestRecharge(unittest.TestCase):
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "recharge")
testcases_data = do_excel.read_data() # 嵌套字典的列表
@classmethod
def setUpClass(cls):
# 3、构造请求参数
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_recharge(self, one_testcase):
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 1、在充值之前，查询当前用例的金额
# 2、进行充值
res = self.do_request.send(one_testcase.method,
new_url,
json=one_testcase.data)
# real_code = res.json()["code"]
try:
self.assertIn(one_testcase.expected_value,
res.text,
one_testcase.name)
# 3、查询充值成功之后的金额
except AssertionError as e:
# my_logger.error(f"{one_testcase.name}：具体异常为{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 = res.json()["data"]["token_info"]["token"]
self.do_request.add_headers("Authorization", f"Bearer {token}")
self.do_excel.write_data(one_testcase, res.text, "成功")
def test_recharge(self, case_list):
self.my_HandleExcel = HandleExcel(DATA_COMMON_FILE_PATH, 'recharge')
if case_list['check_sql']:
before_sql_data = do_mysql.sql_search(
case_list['check_sql'],
virtue=eval(case_list['data'])['mobilephone'])
self.before_leaveamount = float(before_sql_data['LeaveAmount'])
request_result = do_request.send_request(
case_list['method'],
do_config.get_value('request', 'default_address') +
case_list['url_path'], case_list['data'])
actual = int(request_result.json().get('code'))
result = case_list['expected']
msg = case_list['title']
try:
self.assertEqual(result, actual, msg)
if case_list['check_sql']:
after_sql_data = do_mysql.sql_search(
case_list['check_sql'],
virtue=eval(case_list['data'])['mobilephone'])
after_leaveamount = float(after_sql_data['LeaveAmount'])
true_results = after_leaveamount - self.before_leaveamount
self.assertEqual(
eval(case_list['data'])['amount'], round(true_results, 2),
msg)
print('{},执行结果为:{}'.format(msg, true_result))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
true_result)
do_logger.error("{}, 执行结果为: {}".format(msg, true_result))
except AssertionError as e:
print('具体异常为{}'.format(e))
self.my_HandleExcel.write_result(case_list['case_id'] + 1, actual,
fail_result)
do_logger.error("{}, 执行结果为: {},具体异常为{}".format(
msg, fail_result, e))
raise e
class TestLogin(unittest.TestCase):
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "login")
testcases_data = do_excel.read_data() # 嵌套字典的列表
@classmethod
def setUpClass(cls):
# 3、构造请求参数
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_login(self, one_testcase):
# 将excel中读取的请求参数进行参数化
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()
# 将expected_value期望值转化为字典类型
expect_result = json.loads(one_testcase.expected_value,
encoding='utf-8')
try:
# self.assertIn(one_testcase.expected_value,
# res.text,
# one_testcase.name)
self.assertEqual(expect_result.get('code'),
actual_value.get('code'), one_testcase.name)
self.assertEqual(expect_result.get('msg'), actual_value.get('msg'),
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:
self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRegister:
he = HandleExcel('register')
list_obj = he.operate_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequest()
# cls.hm = HandleMysql()
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize('obj', list_obj)
def test_register(self, set_up, obj):
url = hy.read_yaml('excel', 'base_url') + obj.url
request_data = HandleRe.get_data(data=obj.data)
result = set_up[0].send(url=url, data=request_data)
try:
assert [obj.expected,
obj.msg] == [result.json()['code'],
result.json()['msg']]
if obj.caseId == 1:
phone = result.json()['data']['mobile_phone']
mysql_result = set_up[1].get_mysql_result(hy.read_yaml(
'mysql', 'sql'),
args=phone)
assert mysql_result is not None
except AssertionError as e:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='fail')
logger.error(e)
raise e
else:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='success')
logger.info(f"用例{obj.title}执行通过")
finally:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=8,
sheet_value=result.text)
class TestRegister(unittest.TestCase):
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "register")
testcases_data = do_excel.read_data() # 嵌套字典的列表
@classmethod
def setUpClass(cls):
# 3、构造请求参数
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_register(self, one_testcase):
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
res = self.do_request.send(one_testcase.method,
new_url,
json=one_testcase.data)
real_code = res.json()["code"]
# row = testcase_dict["id"] + 1
# self.do_excel.write_data(row, 7, res.text)
# name = testcase_dict["name"]
try:
self.assertEqual(one_testcase.expected_value, real_code,
one_testcase.name)
except AssertionError as e:
# print("此处需要使用日志器来记录日志！")
# my_logger.error(f"{one_testcase.name}：具体异常为{e}")
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# print(f"具体异常为：{e}")
# self.do_excel.write_data(row, 8, "失败")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# self.do_excel.write_data(row, 8, "成功")
# do_log.debug(res.text)
self.do_excel.write_data(one_testcase, res.text, "成功")
class TestAdd:
he = HandleExcel('add')
list_obj = he.operate_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequest()
# cls.hm = HandleMysql()
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize('obj', list_obj)
def test_add(self, set_up, obj):
url = hy.read_yaml('excel', 'base_url') + obj.url
request_data = HandleRe.get_data(data=obj.data)
result = set_up[0].send(url=url, data=request_data)
if obj.caseId == 2:
login_token = result.json()['data']['token_info']['token']
set_up[0].common_head({"Authorization": "Bearer " + login_token})
try:
assert [obj.expected,
obj.msg] == [result.json()['code'],
result.json()['msg']]
except AssertionError as e:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='fail')
logger.error(e)
raise e
else:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='success')
if obj.caseId == 3:
loan_id = result.json()['data']['id']
setattr(HandleRe, 'item_id', loan_id)
logger.info(f"用例{obj.title}执行通过")
finally:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=8,
sheet_value=result.text)
class TestRegisterCase:
he = HandleExcel(sheetname='register')
obj_li = he.read_excel()
# @classmethod
# def setUpClass(cls):
#
# cls.hr.common_head(hy.read_yaml('api', 'header'))
@pytest.mark.parametrize('obj', obj_li)
def test_register(self, set_up, obj):
title = obj.title
base_url = set_up[2].read_yaml('api', 'load')
test_url = obj.url
all_url = ''.join((base_url, test_url))
right_data = HandleRe.my_re(datas=obj.data)
result = set_up[0].send(url=all_url, data=right_data)
try:
assert [result.json()['code'],
result.json()['msg']] == [obj.expected, obj.msg]
if obj.caseId == 1:
my_data = eval(right_data)
bl = set_up[1].mysql_exist(sql=set_up[2].read_yaml(
'mysql', 'phone_sql'),
args=my_data['mobile_phone'])
assert bl
except Exception as e:
self.he.write_excel(row_num=int(obj.caseId) + 1,
col_num=7,
value='fail')
self.he.write_excel(row_num=int(obj.caseId) + 1,
col_num=8,
value=result.text)
set_up[3].error(e)
raise e
else:
self.he.write_excel(row_num=int(obj.caseId) + 1,
col_num=7,
value='success')
self.he.write_excel(row_num=int(obj.caseId) + 1,
col_num=8,
value=result.text)
set_up[3].info(obj.title)
class CaseRegister(unittest.TestCase):
"""
注册用例
"""
do_log = HandleLogging().get_logger()
do_excel = HandleExcel(TEST_DATAS_FILE_PATH2, sheetname='register')
case_list = do_excel.get_cases()
@classmethod
def setUpClass(cls):
cls.do_log.info("\n{:=^40}".format("开始执行用例"))
cls.send_request = HandleSuds()
cls.handle_mysql = HandleMysql()
@classmethod
def tearDownClass(cls):
cls.handle_mysql.close()
cls.do_log.info("\n{:=^40}".format("用例执行结束"))
@data(*case_list)
def test_register(self, one_case):
self.do_log.info("\nRunning Testing Methon:{}".format(inspect.stack()[0][3]))
new_data = Context.register_parameterization(one_case.data)
res = self.send_request(url=one_case.url, api=one_case.api, data=new_data)
if one_case.api.lower() == 'sendmcode' and res == 'ok':
one_dict = json.loads(new_data, encoding='utf-8')
Context.registing_tel = one_dict["mobile"]
check_sql = one_case.check_sql
if check_sql:
check_sql = Context.registing_tel_replace(check_sql)
mysql_data = self.handle_mysql(sql=check_sql)
Context.verify_code = mysql_data["Fverify_code"]
actual_result = str(res)
expect_result = str(one_case.expected)
try:
self.assertEqual(expect_result, actual_result, msg="测试{}失败".format(one_case.title))
except AssertionError as e:
self.do_log.error("具体异常为：{}".format(e))
self.do_excel.write_result(row=one_case.case_id + 1, actual=str(res), result='Fail')
raise e
else:
self.do_excel.write_result(row=one_case.case_id + 1, actual=str(res), result='pass')
class TestRegister:
obj_li = HandleExcel('register')
cases = obj_li.read_excel()
@pytest.mark.parametrize('case', cases)
def test_register(self, set_up, case):
url = hy.read_yaml('request', 'base_url') + case.url
data = HandleRe.handle_para(case.data)
res = set_up[0].send(url=url, data=data)
try:
assert [case.expected, case.msg] == [res.json()['code'], res.json()['msg']]
self.obj_li.write_excel(int(case.caseId) + 1, 8, value=str(res.json()))
except AssertionError as e:
my_logger.error(f'用例{case.title}断言失败')
self.obj_li.write_excel(int(case.caseId)+1,7, value='fail')
raise e
else:
my_logger.info(f'用例{case.title}断言成功')
self.obj_li.write_excel(int(case.caseId)+1,7, value='success')
class TestLogin:
he = HandleExcel('login')
list_obj = he.operate_excel()
# @classmethod
# def setUpClass(cls) -> None:
# cls.hr = HandleRequest()
# cls.hm = HandleMysql()
#
# @classmethod
# def tearDownClass(cls) -> None:
# cls.hr.close()
# cls.hm.close()
@pytest.mark.parametrize('obj', list_obj)
def test_login(self, set_up, obj):
url = hy.read_yaml('excel', 'base_url') + obj.url
# if obj.caseId == 2:
# HandlePhone.loop_generate_phone()
request_data = HandleRe.get_data(data=obj.data)
result = set_up[0].send(url=url, data=request_data)
try:
assert [obj.expected,
obj.msg] == [result.json()['code'],
result.json()['msg']]
# self.assertListEqual([obj.expected, obj.msg], [result.json()['code'], result.json()['msg']],
# msg=f"用例{obj.title}执行完成")
except AssertionError as e:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='fail')
logger.error(e)
raise e
else:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=7,
sheet_value='success')
logger.info(f"用例{obj.title}执行通过")
finally:
self.he.write_excel(rowid=int(obj.caseId) + 1,
colid=8,
sheet_value=result.text)
