def test_invest(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 result.get('data'):
if result.get('data').get('token_info'):
self.do_request.add_headers({"Authorization": \
"Bearer " + result['data']['token_info']['token']})
# 取出load id的第一种方法
# check_sql = case.check_sql # 取出check_sql
# if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验
# check_sql = HandleParam.to_param(check_sql) # 将check_sql进行参数化
# mysql_data = self.do_mysql.run(check_sql) # 执行sql
# load_id = mysql_data['id']
# # 动态创建属性的机制, 来解决接口依赖的问题
# setattr(HandleParam, 'loan_id', load_id)
# 取出load id的第二种方法
if case.case_id == 2:
load_id = result.get('data').get('id')
setattr(HandleParam, 'loan_id', load_id)
def create_new_user(reg_name, pwd='12345678', type=1):
"""
创建一个新用户
:param reg_name:
:param pwd:
:param type:
:return:
"""
# 创建session会话对象，用来发起请求
do_request = HandleRequest()
# 创建mysql对象
do_mysql = HandleMysql()
# 添加公共请求头
do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 注册请求的url
register_url = do_yaml.read_yaml('api', 'prefix') + '/member/register'
while True:
# 随机生成一个未注册的手机号
mobile_phone = do_mysql.create_not_exsited_mobile()
# 创建一个请求体参数
data = {
'mobile_phone': mobile_phone,
'pwd': pwd,
'type': type,
'reg_name': reg_name
}
# 调用注册接口，发起请求
do_request.send(register_url, data=data)
# 查询数据库用户ID的sql，同时进行了数据校验
sql = do_yaml.read_yaml('mysql', 'select_user_id_sql')
# 查询数据库，获取用户ID
result = do_mysql.run(sql, args=[mobile_phone], is_more=False)
# 判断是否存在，如果result为None，则用户不存在，if语句为真，用户创建成功，跳出循环
if result:
user_id = result['id']
break
# 构建用户信息为嵌套字典的字典
user_info = {
reg_name: {
'user_id': user_id,
'mobile_phone': mobile_phone,
'pwd': pwd,
'reg_name': reg_name}
}
# 关闭mysql对象
do_mysql.close()
# 关闭session会话对象
do_request.close()
return user_info
def __init__(self):
# 建立连接
self.conn = pymysql.connect(host=do_yaml.read_yaml('mysql', 'host'), # mysql服务器ip或者域名
user=do_yaml.read_yaml('mysql', 'user'), # 用户名
password=do_yaml.read_yaml('mysql', 'password'), # 密码
db=do_yaml.read_yaml('mysql', 'db'), # 要连接的数据库名
port=do_yaml.read_yaml('mysql', 'port'), # 数据库端口号，默认为3306
charset='utf8', # 数据库编码为utf8，不能写成utf-8
cursorclass=pymysql.cursors.DictCursor # 游标类型设置,使返回数据为字典
)
# 创建游标对象
self.cursor = self.conn.cursor()
def __init__(self, sheetname, filename=None):
if filename is None:
self.filename = os.path.join(
DATAS_DIR, do_yaml.read_yaml('excel', 'data_name'))
else:
self.filename = filename
self.sheetname = sheetname
def setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建数据库处理对象
cls.do_mysql = HandleMysql()
def setUpClass(cls):
# 创建session对象
cls.do_request = HandleRequest()
# 添加到配置文件并设置公共请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建mysql数据连接，用来做数据校验
cls.do_mysql = HandleMysql()
def is_existed_mobile(self, mobile):
'''
判断生成的手机号是否已经存在
:param mobile: mobile是待查询的手机号
:return: 手机号能查到存在返回True，不存在返回Fales
'''
sql = do_yaml.read_yaml('mysql', 'select_user_sql')
if self.run(sql, args=[mobile]):
return True
else:
return False
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
# 将json格式的字符串转换为字典格式，得到期望值
excepted_result = json.loads(excepted_result, encoding='utf-8')
# 获取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.get('code'),
msg=msg)
self.assertEqual(actual_value.get('msg'),
excepted_result.get('msg'),
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:
# 回写断言结果
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 create_logger(cls):
my_log = logging.getLogger(do_yaml.read_yaml('log', 'log_name'))
my_log.setLevel(do_yaml.read_yaml('log', 'logger_level'))
# 创建输出格式
formatter = logging.Formatter(do_yaml.read_yaml(
'log', 'log_formatter'))
# 创建到控制台的输出渠道
stream = logging.StreamHandler()
stream.setLevel(do_yaml.read_yaml('log', 'stream_levle'))
stream.setFormatter(formatter)
my_log.addHandler(stream)
# 创建到文件的输出渠道，文件目录和配置文件中的文件名进行拼接
filer = logging.FileHandler(filename=os.path.join(
LOGS_DIR, do_yaml.read_yaml('log', 'logfile_name')),
encoding='utf8')
filer.setLevel(do_yaml.read_yaml('log', 'logfile_level'))
filer.setFormatter(formatter)
my_log.addHandler(filer)
return my_log
def create_logger(cls):
# 创建日志收集器设置等级
logger = logging.getLogger(do_yaml.read_yaml('log', 'log_name'))
logger.setLevel(do_yaml.read_yaml('log', 'logger_level'))
# 设置输出格式
formatter = logging.Formatter(do_yaml.read_yaml(
'log', 'log_formatter'))
# 创建输出到控制台的日志输出渠道对象，设置等级
stream = logging.StreamHandler()
stream.setLevel(do_yaml.read_yaml('log', 'stream_levle'))
stream.setFormatter(formatter)
# 将渠道对象加入到日志收集器
logger.addHandler(stream)
# 创建输出到文件的输出渠道对象，设置等级并加入到日志收集器
filer = logging.FileHandler(os.path.join(
LOGS_DIR, do_yaml.read_yaml('log', 'logfile_name')),
encoding='utf8')
filer.setLevel(do_yaml.read_yaml('log', 'logfile_level'))
filer.setFormatter(formatter)
logger.addHandler(filer)
return logger
def __init__(self):
# 1 建立连接
# self.conn = pymysql.connect(host='api.lemonban.com', # mysql服务器IP或者域名
# user='******', # 用户名
# password='******', # 密码
# db='futureloan', # 要连接的数据库名
# port=3306, # 数据库端口号，默认为3306，也可以不写
# charset='utf8', # 数据库编码为utf8,不能写为utf-8
# cursorclass=pymysql.cursors.DictCursor # 添加游标类，取结果的时候返回的字典类型；不添加返回元组
# )
self.conn = pymysql.connect(
host=do_yaml.read_yaml('mysql', 'host'), # mysql服务器IP或者域名
user=do_yaml.read_yaml('mysql', 'user'), # 用户名
password=do_yaml.read_yaml('mysql', 'password'), # 密码
db=do_yaml.read_yaml('mysql', 'db'), # 要连接的数据库名
port=do_yaml.read_yaml('mysql', 'port'), # 数据库端口号，默认为3306，也可以不写
charset='utf8', # 数据库编码为utf8,不能写为utf-8
cursorclass=pymysql.cursors.
DictCursor # 添加游标类，取结果的时候返回的字典类型（结果不唯一的话返回嵌套字典的列表）；不添加返回元组
)
# 2.创建游标对象
self.cursor = self.conn.cursor()
def is_existed_mobile(self, mobile):
"""
判断手机号是否被注册
:param mobile: 待判断是否注册的手机号
:return:
"""
# sql = "select * from member where mobile_phone = %s;"
sql = do_yaml.read_yaml('mysql', 'select_user_sql')
# 已注册（run函数返回数据，即if表达式为真），返回True；查询不到结果（None），返回False
if self.run(sql, args=[mobile], is_more=False):
return True
else:
return False
def test_invest(self, case):
expected = case.expected
# 取出data并进行参数化
case_data = HandleParams.replace_params(case.data)
# url
url = do_yaml.read_yaml('api', 'url') + case.url
# 发起请求
res = self.do_requests.send(url=url,
method=case.request_method,
data=case_data)
# 结果转为字典
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
try:
# assertEqual第三个参数为用例执行失败之后的提示信息
self.assertEqual(expected, result['code'], msg=msg)
except AssertionError as e:
# 输出日志
do_logs.info("{}用例执行有误".format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=fail_msg)
do_logs.error('具体异常为{}'.format(e))
raise e
else:
do_logs.info('{}用例执行通过'.format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=success_msg)
# 执行用例通过后，判断返回报文中有没有token，有的话取出加到请求头中
if 'token_info' in res.text:
token = result['data']['token_info']['token']
self.do_requests.add_headers(
{"Authorization": "Bearer " + token})
# 加标成功之后取出loan_id，如果用例中有check_sql，则要进行数据校验
check_sql = case.check_sql
if check_sql:
check_sql = HandleParams.replace_params(check_sql)
loan_id = self.do_mysql.run_sql(check_sql)
# 创建动态属性的方式来处理接口依赖
setattr(HandleParams, 'loan_id', loan_id['id'])
finally:
# 将实际结果写入
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
def user_init():
# 获取请求头
headers = do_yaml.read_yaml('api', 'version')
# 创建请求对象
do_request = HandleRequests()
# 添加公共请求头
do_request.add_headers(headers)
# url
url = 'http://api.lemonban.com/futureloan/member/register'
# 用户数据
user_datas = [{
'mobile_phone': '',
'pwd': '12345678',
'type': 0,
'reg_name': '管理员'
}, {
'mobile_phone': '',
'pwd': '12345678',
'type': 1,
'reg_name': '借款人'
}, {
'mobile_phone': '',
'pwd': '12345678',
'type': 1,
'reg_name': '投资人'
}]
write_yaml = HandleYaml(USER_FILE_DIR)
# 连接数据库
do_mysql = HandleMysql()
user_info = {}
# 生成手机号并注册
for user in user_datas:
user['mobile_phone'] = do_mysql.create_not_existed_mobile()
# 请求注册接口，返回数据转换成字典并存入字典
res = do_request.send(url, data=user).json()
# 获取用户id、密码等信息(区域名为昵称，选项名为data里的字段名以及密码)
user_info['{}'.format(user['reg_name'])] = res['data']
user_info['{}'.format(user['reg_name'])]['pwd'] = user['pwd']
# 写入用户文件
write_yaml.write_yaml(USER_FILE_DIR, user_info)
# 断开数据库
do_mysql.close()
# 断开请求
do_request.close()
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_register(self, case):
expected = case.expected
# 取出data并进行参数化
case_data = HandleParams.replace_params(case.data)
# url
url = do_yaml.read_yaml('api', 'url') + case.url
# 发起请求
res = self.do_requests.send(url=url,
method=case.request_method,
data=case_data)
# 结果转为字典
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
try:
# assertEqual第三个参数为用例执行失败之后的提示信息
self.assertEqual(expected, result['code'], msg=msg)
except AssertionError as e:
# 输出日志
do_logs.info("{}用例执行有误".format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=fail_msg)
do_logs.error('具体异常为{}'.format(e))
raise e
else:
do_logs.info('{}用例执行通过'.format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=success_msg)
finally:
# 将实际结果写入
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
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 handle_logger(cls):
# 创建一个日志收集器
# my_log = logging.getLogger('my_log')
my_log = logging.getLogger(do_yaml.read_yaml('log', 'log_name'))
# 设置收集等级
# my_log.setLevel('DEBUG')
my_log.setLevel(do_yaml.read_yaml('log', 'in_level'))
# 设置输出格式
# formater = logging.Formatter('%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s')
formater = logging.Formatter(
do_yaml.read_yaml('log', 'formater_content'))
# 输出到控制台
sh = logging.StreamHandler()
# 设置输出等级
# sh.setLevel("WARNING")
sh.setLevel(do_yaml.read_yaml('log', 'out_level'))
# 将输出格式设置到控制台
sh.setFormatter(formater)
# 将输出终端添加到收集器
my_log.addHandler(sh)
# 输出到日志文件
# fh = logging.FileHandler('log_1106.log', encoding='utf8')
# fh = logging.FileHandler(do_yaml.read_yaml('log', 'log_file'), encoding='utf8')
fh = logging.FileHandler(os.path.join(
LOGS_DIR, do_yaml.read_yaml('log', 'log_file')),
encoding='utf8')
# 设置输出等级
# fh.setLevel("WARNING")
fh.setLevel(do_yaml.read_yaml('log', 'out_level'))
# 将输出格式设置到日志文件
fh.setFormatter(formater)
# 将输出终端添加到收集器
my_log.addHandler(fh)
# 返回收集器
return my_log
def setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
def setUpClass(cls):
cls.do_requests = HandleRequests()
cls.do_requests.add_headers(do_yaml.read_yaml('api', 'version'))
def to_parameter(cls, data):
# 使用正则进行匹配得到包含未注册手机号的data
if re.search(cls.not_existed_tel_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
# 匹配得到含有未注册手机号的data
data = re.sub(cls.not_existed_tel_pattern,
do_mysql.create_not_exsited_mobile(), data)
# 关闭数据库游标对象、连接
do_mysql.close()
# 已存在的手机号:投资人手机号
if re.search(cls.existed_tel_pattern, data):
# 匹配得到含有已存在的手机号的data
data = re.sub(
cls.existed_tel_pattern,
cls.do_yaml_user.read_yaml('investor', 'mobile_phone'), data)
# 已存在手机号的密码：投资人密码
if re.search(cls.existed_pwd_pattern, data):
# 匹配得到含有已存在手机号的密码的data
data = re.sub(cls.existed_pwd_pattern,
cls.do_yaml_user.read_yaml('investor', 'pwd'), data)
# 会员ID：投资人ID
if re.search(cls.existed_investor_id_pattern, data):
# 匹配得到含有投资人会员ID的data
data = re.sub(
cls.existed_investor_id_pattern,
str(cls.do_yaml_user.read_yaml('investor', 'user_id')), data)
# 不存在的投资人ID
if re.search(cls.not_existed_id_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
# 配置文件中获取sql
# 这里也可以不把sql语句写入配置文件，直接将sql语句写在下面
sql = do_yaml.read_yaml('mysql', 'select_user_max_id_sql')
# 运行sql，得到一个字典
res_max = do_mysql.run(sql, is_more=False)
# 获取字典的值，转换为字符串，将原data进行参数化
data = re.sub(cls.not_existed_id_pattern,
str(res_max.get('max(id)') + 1), data)
# 关闭数据库游标对象、连接
do_mysql.close()
# 借款人ID
# 正则匹配：查找
if re.search(cls.existed_borrower_id_pattern, data):
data = re.sub(
cls.existed_borrower_id_pattern,
str(cls.do_yaml_user.read_yaml('borrower', 'user_id')), data)
# 借款人电话
if re.search(cls.existed_borrower_tel_pattern, data):
data = re.sub(
cls.existed_borrower_tel_pattern,
cls.do_yaml_user.read_yaml('borrower', 'mobile_phone'), data)
# 借款人密码
if re.search(cls.existed_borrower_pwd_pattern, data):
data = re.sub(cls.existed_borrower_pwd_pattern,
cls.do_yaml_user.read_yaml('borrower', 'pwd'), data)
# 管理员电话
if re.search(cls.existed_admin_tel_pattern, data):
data = re.sub(cls.existed_admin_tel_pattern,
cls.do_yaml_user.read_yaml('admin', 'mobile_phone'),
data)
# 管理员密码
if re.search(cls.existed_admin_pwd_pattern, data):
data = re.sub(cls.existed_admin_pwd_pattern,
cls.do_yaml_user.read_yaml('admin', 'pwd'), data)
# loan_id
if re.search(cls.loan_id_pattern, data):
loan_id = getattr(Parameterize, 'loan_id')
data = re.sub(cls.loan_id_pattern, str(loan_id), data)
# 不存在的loan_id
if re.search(cls.not_existed_loan_id_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
sql = "select id from loan order by id desc limit 0,1;"
# 运行sql，得到一个字典
res_max = do_mysql.run(sql, is_more=False)
# 获取字典的值，转换为字符串，将原data进行参数化
data = re.sub(cls.not_existed_loan_id_pattern,
str(res_max.get('id') + 1), data)
# 关闭数据库游标对象、连接
do_mysql.close()
return data
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_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)
# 判断返回报文中是否有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']})
# 取出load id的第一种方法
# check_sql = case.check_sql # 取出check_sql
# if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验
# check_sql = HandleParam.to_param(check_sql) # 将check_sql进行参数化
# mysql_data = self.do_mysql.run(check_sql) # 执行sql
# load_id = mysql_data['id']
# # 动态创建属性的机制, 来解决接口依赖的问题
# setattr(HandleParam, 'loan_id', load_id)
# 取出load id的第二种方法
if case.case_id == 2:
load_id = result.get('data').get('id')
setattr(HandleParam, 'loan_id', load_id)
finally:
# 将响应实际结果写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
if __name__ == "__main__":
red = TestInvest()
if not os.path.exists(USER_INFO_DIR):
generate_user_yaml()
# # 创建测试套件对象，导入用到的unittest的TestSuite
# suite = unittest.TestSuite()
# # 将测试用例添加到测试套件中：
# # 分为四种方法，使用ddt后这里使用将测试模块加入到测试套件中(导入测试用例类所在的模块）
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromModule(test_01_register))
# suite.addTest(loader.loadTestsFromModule(test_02_login))
# 创建目录测试套件对象，使用unittest.defaultTestLoader.discover()
suite = unittest.defaultTestLoader.discover(CASES_DIR)
# 创建测试运行程序
# runner = unittest.TextTestRunner()
# 也可以生成测试报告，将HTMLTestRunnerNew.py放入python安装目录--lib下，并在该模块导入
report_name = do_yaml.read_yaml('report', 'report_name') + '_' \
+ datetime.strftime(datetime.now(), '%Y%m%d%H%M%S')
report_name = os.path.join(REPORTS_DIR, report_name)
with open(report_name + '.html', 'wb') as f:
runner = HTMLTestRunner(stream=f,
verbosity=2,
title=do_yaml.read_yaml('report', 'report_title'),
description=do_yaml.read_yaml('report', 'report_description'),
tester=do_yaml.read_yaml('report', 'report_tester'))
# 将测试套件添加到测试运行程序
runner.run(suite)
def setUpClass(cls):
# 创建session对象
cls.do_request = HandleRequest()
# 设置公共请求头并添加到配置文件
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
def test_recharge(self, case):
expected = case.expected
# 取出data并进行参数化
case_data = HandleParams.replace_params(case.data)
# url
url = do_yaml.read_yaml('api', 'url') + case.url
# 充值前，去数据库获取充值前金额
check_sql = case.check_sql
if check_sql:
check_sql = HandleParams.replace_params(check_sql)
mysql_data = self.do_mysql.run_sql(check_sql)
old_amount = round(float(mysql_data['leave_amount']),
2) # 取出当前金额，保留两位小数
# 发起请求
res = self.do_requests.send(url=url,
method=case.request_method,
data=case_data)
# 结果转为字典
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
try:
# assertEqual第三个参数为用例执行失败之后的提示信息
self.assertEqual(expected, result['code'], msg=msg)
# 充值成功之后再去数据库取当前金额对比
if check_sql:
new_amount = round(
float(self.do_mysql.run_sql(check_sql)['leave_amount']), 2)
recharge_amount = json.loads(case_data)['amount']
actual_amount = round(new_amount - old_amount, 2)
self.assertEqual(recharge_amount, actual_amount, msg=msg)
except AssertionError as e:
# 输出日志
do_logs.info("{}用例执行有误".format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=fail_msg)
do_logs.error('具体异常为{}'.format(e))
raise e
else:
do_logs.info('{}用例执行通过'.format(msg))
# 写入用例执行结果
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=success_msg)
# 执行用例通过后，判断返回报文中有没有token，有的话取出加到请求头中
if 'token_info' in res.text:
self.do_requests.add_headers({"Authorization": "Bearer " + \
result['data']['token_info']['token']})
finally:
# 将实际结果写入
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
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)
from scripts.handle_path import REPORTS_DIR, USER_ACCOUNTS_FILE_DIR, CASES_DIR
# 导入初始化三个用户的模块
from scripts.handle_user import UserInit
# 运行测试前先判断用户是否已经有初始化，存在目录则不需要执行初始化
if not os.path.exists(USER_ACCOUNTS_FILE_DIR):
UserInit.user_init()
# 创建测试套件
# suite = unittest.TestSuite()
#
# # 加载用例到测试套件
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromModule(test_register_case))
# suite.addTest(loader.loadTestsFromModule(test_login_case))
suite = unittest.defaultTestLoader.discover(CASES_DIR)
# 添加报告路径
result_full_path = do_yaml.read_yaml('report', 'report_name') + '_' + \
datetime.strftime(datetime.now(), '%Y%m%d%H%M%S') + '.html'
result_full_path = os.path.join(REPORTS_DIR, result_full_path)
with open(result_full_path, 'wb') as f:
runner = HTMLTestRunner(stream=f,
title=do_yaml.read_yaml('report', 'title'),
description=do_yaml.read_yaml(
'report', 'description'),
tester=do_yaml.read_yaml('report', 'tester'))
runner.run(suite)
