def create_log(cls):
# 创建一个日志收集器
my_log = logging.getLogger(do_yaml.read("log", "log_name"))
# 设置日志的收集等级
my_log.setLevel("DEBUG")
# 设置日志的输出格式
formater = "%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s"
# 创建一个输出到控制台的日志输出渠道
sh = logging.StreamHandler()
# 设置输出到控制台的日志输出等级
sh.setLevel("DEBUG")
# 设置日志的输出格式
sh.setFormatter(logging.Formatter(formater))
# 将输出到控制台的日志输出渠道添加到日志收集器
my_log.addHandler(sh)
# 日志文件生成路径
filepath = datetime.strftime(datetime.now(),
'%Y%m%d%H%M%S') + "_" + do_yaml.read(
"log", "logfile_name")
# 创建输出到文件的日志输出渠道
fh = logging.FileHandler(filename=os.path.join(LOGS_DIR, filepath),
encoding="utf8")
# 设置输出到文件的日志格式
fh.setFormatter(logging.Formatter(formater))
# 设置输出刀片文件的日志输出等级
fh.setLevel("DEBUG")
#将输出到控制台的日志输出渠道添加到日志收集器
my_log.addHandler(fh)
return my_log
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()
def __init__(self):
self.conn = pymysql.connect(
host=do_yaml.read('mysql', 'host'), # mysql服务器ip或者域名
user=do_yaml.read('mysql', 'user'), # 用户名
password=do_yaml.read('mysql', 'password'),
db=do_yaml.read('mysql', 'db'), # 要连接的数据库名
port=do_yaml.read('mysql', 'port'), # 数据库端口号, 默认为3306
charset='utf8', # 数据库编码为utf8, 不能设为utf-8
# 默认返回的结果为元祖或者嵌套元祖的列表
# 可以指定cursorclass为DictCursor, 那么返回的结果为字典或者嵌套字典的列表
cursorclass=pymysql.cursors.DictCursor)
self.cursor = self.conn.cursor()
def __init__(self):
# 1.建立连接
self.conn = pymysql.connect(host=do_yaml.read('mysql', 'host'), # mysql服务器ip或者域名
user=do_yaml.read('mysql', 'user'), # 用户名
password=do_yaml.read('mysql', 'password'), # 密码
db=do_yaml.read('mysql', 'db'), # 要连接的数据库名
port=do_yaml.read('mysql', 'port'), # 数据库端口号默认为3306
charset='utf8', # 数据库编码为utf8,不能写为utf-8
cursorclass=pymysql.cursors.DictCursor # 返回的结果为字典或者嵌套字典的列表
)
# 2.使用连接对象创建游标对象
self.cursor = self.conn.cursor()
def create_new_user(reg_name, pwd="aaa123", user_type=1):
"""
创建一个用户
:param reg_name: 用户名
:param pwd: 密码
:param user_type: 用户类型
:return: 存储一个用户信息, 嵌套字典的字典(以用户名为key, 以用户信息所在字典为value)
"""
# 建立连接
do_mysql = HandleMysql()
do_request = HandleRequest()
# 添加公共请求头
do_request.add_headers(do_yaml.read('api', 'version'))
url = do_yaml.read('api', 'prefix') + '/member/register'
sql = do_yaml.read('mysql', 'select_userid_sql')
while True:
mobile_phone = do_mysql.create_not_existed_mobile()
data = {
"mobile_phone": mobile_phone,
"pwd": pwd,
"reg_name": reg_name,
"type": user_type
}
# 先注册接口发起请求
do_request.send(url, data=data)
# 查询数据库, 获取用户id
result = do_mysql.run(sql=sql, args=(mobile_phone, ))
if result:
user_id = result["id"]
break
# 构造用户信息字典
user_dict = {
reg_name: {
"id": user_id,
"reg_name": reg_name,
"mobile_phone": mobile_phone,
"pwd": pwd
}
}
# 关闭连接
do_mysql.close()
do_request.close()
return user_dict
def __init__(self, sheetname, filename=None):
if filename is None:
self.filename = os.path.join(DATAS_DIR,
do_yaml.read("excel", "cases_path"))
else:
self.filename = filename
self.sheetname = sheetname
def setUpClass(cls) -> None:
# 创建请求对象
cls.do_request = HandleRequest()
# 添加公共请求头
cls.do_request.add_headers(do_yaml.read("api", "version"))
#创建mysql对象
cls.do_mysql = HandleMysql()
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}'
def is_existed_mobile(self, mobile):
"""判断收集好是否被注册"""
sql = do_yaml.read("mysql", "sql")
if self.run(sql, args=[mobile]):
return True
else:
return False
def create_new_user(reg_name, pwd="12345678", user_type=1):
'''
创建用户
reg_name:用户昵称
pwd:密码
user_type:用户类型
返回一个用户信息，嵌套字典的字典，用户昵称为key,用户信息为value
'''
# 建立连接 后面要关闭连接
do_mysql = HandleMysql()
do_request = HandleRequest()
# 添加公共请求头
do_request.add_headers(do_yaml.read('api', 'version'))
url = do_yaml.read('api', 'prefix') + '/member/register'
sql = do_yaml.read(
'api', 'select_user_id') # 虽然响应报文中会返回用户ID，但是从数据库中取出，进一步数据校验了注册接口
while True: # 因为存在数据库中找不到手机号的可能，所以直接死循环创建一个未注册的手机号确保万无一失
mobile_phone = do_mysql.create_not_existed_mobile()
data = {
"mobile_phone": mobile_phone,
"pwd": pwd,
"reg_name": reg_name,
"type": user_type
}
# 向注册接口发起请求
do_request.send(url, data=data)
# 查询数据库，获取用户id
result = do_mysql.run(sql=sql, args=(mobile_phone, ))
if result: # 如果查询结果不为空，则获取id
user_id = result['id']
break
# 构造用户信息字典
user_dict = {
reg_name: {
"id": user_id,
"mobile_phone": mobile_phone,
"pwd": pwd,
"reg_name": reg_name,
}
}
# 关闭连接
do_request.close()
do_mysql.close()
return user_dict
def test_case_method(self, case): # 实例方法名不能跟模块名一致
# 1.参数化
new_data = Parameterize.to_param(case.data)
# 2.拼接完整的URL
new_url = do_yaml.read('api', 'prefix') + case.url
# excel 中check_sql一栏不为空就去获取充值前的金额
check_sql = case.check_sql
if check_sql:
check_sql = Parameterize.to_param(check_sql)
mysql_data = self.do_mysql.run(check_sql)
amount_before = float(
mysql_data['leave_amount']) # 是decimal类型,所以先转换成float
amount_before = round(amount_before, 2) # 保留为2位小数
# 3.向服务器发起请求
res = self.do_request.send(
url=new_url,
method=case.method, # 可省略
data=new_data,
is_json=True # 可省略
)
# 将响应报文中的数据转化为字典
actual_value = res.json()
# 获取测试用例行号
row = case.case_id + 1
# 获取期望值
expected_results = case.expected # 只做code的校验，不需要转换json
msg = case.title # 获取标题
success_msg = do_yaml.read('msg', 'success_result')
fail_msg = do_yaml.read('msg', 'fail_result')
try:
# assertEqual 第一个参数为期望值，第二个参数为实际值，第三个参数为用例执行失败之后的提示信息
self.assertEqual(expected_results,
actual_value.get('code'),
msg=msg)
except AssertionError as e:
# 将响应实际值写入到actual列
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'actual_col'),
value=res.text) # 响应文本是字典不能直接写入，转换文本写入
# 将用例执行结果写入到result列
# log.info('用例{}执行未通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=fail_msg)
log.info(f":{msg}，执行的结果为：{fail_msg}\n,具体异常为{e}\n")
raise e
else:
# log.info('用例{}执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'actual_col'),
value=res.text)
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=success_msg)
log.info(f":{msg}，执行的结果为：{success_msg}\n")
def test_register(self, case):
# src_data = case.data
# re.sub(r'{not_existed_tel}', '', src_data)
# 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, # url地址
# method=case.method, # 请求方法
data=new_data, # 请求参数
# is_json=True # 是否以json格式来传递数据, 默认为True
)
# 将相应报文中的数据转化为字典
actual_value = res.json()
# 获取用例的行号
row = case.case_id + 1
# 获取预期结果
# excepted = eval(case.excepted)
expected_result = case.expected
msg = case.title # 获取标题
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
# assertEqual第三个参数为用例执行失败之后的提示信息
# assertEqual第一个参数为期望值, 第二个参数为实际值
self.assertEqual(expected_result,
actual_value.get('code'),
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:
# 将相应实际值写入到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_add(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)
# 将执行结果写入到日志中
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_login(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, # url地址
# method=case.method, # 请求方法
data=new_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:
# 将相应实际值写入到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 is_existed_mobile(self, mobile):
"""
判断手机号是否被注册
:param mobile: 待查询的手机号
:return:
"""
sql = do_yaml.read('mysql', 'select_user_sql')
if self.run(sql, args=[mobile]):
return True
else:
return False
def create_logger(cls):
"""创建日志收集器"""
# 创建一个日志收集器
my_log = logging.getLogger(do_yaml.read("log", "log_name"))
# 设置日志收集器的收集等级
my_log.setLevel(do_yaml.read("log", "logger_level"))
# 设置日志输出的格式
formater = logging.Formatter(do_yaml.read("log", "formatter"))
# 创建一个输出导控制台的日志输出渠道
sh = logging.StreamHandler()
sh.setLevel(do_yaml.read("log", "stream_level"))
# 设置输出导控制台的格式
sh.setFormatter(formater)
# 将输出渠道添加到日志收集器中
my_log.addHandler(sh)
# 创建一个输出导文件的渠道
fh = logging.FileHandler(filename=os.path.join(
LOGS_DIR, do_yaml.read("log", "logfile_name")),
encoding='utf8')
fh.setLevel(do_yaml.read("log", "logfile_level"))
# 设置输出导文件的日志格式
fh.setFormatter(formater)
# 将输出渠道添加到日志收集器中
my_log.addHandler(fh)
return my_log
def create_logger(cls):
'''
用来创建日志收集器
:return:
'''
# 创建一个日志收集器
my_log = logging.getLogger(do_yaml.read('log', 'log_name'))
# 设置日志收集器的收集等级
my_log.setLevel(do_yaml.read('log', 'log_level'))
# 设置日志输出的格式
formatter = logging.Formatter(do_yaml.read('log', 'formatter'))
# 日志的输出
# 创建一个输出到控制台的日志输出渠道
sh = logging.StreamHandler()
sh.setLevel(do_yaml.read('log', 'stream_level'))
sh.setFormatter(formatter)
# 将输出渠道添加到日志收集器中
my_log.addHandler(sh)
# 创建一个输出到文件的输出渠道
fh = logging.FileHandler(filename=os.path.join(
LOGS_DIR, do_yaml.read('log', 'logfile_name')),
encoding='utf8')
fh.setLevel(do_yaml.read('log', 'log_file_level'))
fh.setFormatter(formatter)
# 将输出渠道添加到日志收集器中
my_log.addHandler(fh)
return my_log
def test_case_method(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,
method=case.method, # 可省略
data=new_data,
is_json=True # 可省略
)
# 将响应报文中的数据转化为字典
actual_value = res.json()
# 获取测试用例行号
row = case.case_id + 1
# 获取期望值
expected_results = 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:
# assertEqual 第一个参数为期望值，第二个参数为实际值，第三个参数为用例执行失败之后的提示信息
self.assertEqual(expected_results,
actual_value.get('code'),
msg=msg)
self.assertEqual(expected_results.get('msg'),
actual_value.get('msg'),
msg=msg)
except AssertionError as e:
# 将响应实际值写入到actual列
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'actual_col'),
value=res.text) # 响应文本是字典不能直接写入，转换文本写入
# 将用例执行结果写入到result列
# log.info('用例{}执行未通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=fail_msg)
log.info(f":{msg}，执行的结果为：{fail_msg}\n,具体异常为{e}\n")
raise e
else:
# log.info('用例{}执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'actual_col'),
value=res.text)
self.excel.write_data(row=row,
column=do_yaml.read('excel', 'result_col'),
value=success_msg)
log.info(f":{msg}，执行的结果为：{success_msg}\n")
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'))
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_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 setUpClass(cls) -> None:
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.read("api", "version"))
# 将测试用例对象，加入测试套件
# suite.addTest(case)
# 第二种方法：将测试用例类中所有的测试用例，加入到测试套件
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromTestCase(TestInvest))
# 第三种方法：将一个模块中的所有测试用例 加载到测试套件
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromModule("E:\Workspace\Lemon_Api_Test\cases\test_05_invest.py"))
# 第四种方法：通过一个目录，去导入该目录下的所有模块种的测试用例
# discover方法可以控制测试用例目录下测试用例模块的执行顺序，默认执行测试用例目录下test*.py文件（test后的ascii码越小最先执行）
loader = unittest.TestLoader()
suite.addTest(loader.discover(CESES_DIR))
# 测试报告名称
result_full_path = do_yaml.read("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 one:
# 创建测试运行程序
runner = HTMLTestRunner(stream=one,
title=do_yaml.read("report", "title"),
description=do_yaml.read("report", "description"),
tester=do_yaml.read("report", "tester"))
# 运行测试用例.0
runner.run(suite)
from scripts.handle_log import log
from scripts.handle_yaml import do_yaml
from scripts.handle_path import REPORTS_DIR, USER_ACCOUNT_FILE_PATH, CASES_DIR
from scripts.handle_user import generate_users_config
# 如果用户账号所在文件不存在，则创建用户账号，否则不创建
if not os.path.exists(USER_ACCOUNT_FILE_PATH):
generate_users_config()
# 创建测试套件
# suite = unittest.TestSuite()
# log.info('测试套件创建成功')
# # 加载测试用例到测试套件
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromModule(test_01_register))
# suite.addTest(loader.loadTestsFromModule(test_02_login))
suite = unittest.defaultTestLoader.discover(CASES_DIR)
log.info('测试用例加载完毕')
# 加一个时间戳输出报告，避免后面的报告覆盖前面的报告
result_full_path = do_yaml.read('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 fb:
runner = HTMLTestRunner(stream=fb,
verbosity=2,
title=do_yaml.read('report', 'title'),
description=do_yaml.read('report', 'description'),
tester=do_yaml.read('report', 'tester'))
# 执行测试套件中的测试用例
runner.run(suite)
log.info('所有的用例已经运行完毕')
# 如果用户账号所在文件不存在, 则创建用户账号, 否则不创建
if not os.path.exists(USER_ACCOUNTS_FILE_PATH):
generate_users_config()
# from cases import test_01_register
# 创建测试套件
# suite = unittest.TestSuite()
# 加载用例用例到套件
# loader = unittest.TestLoader()
# suite.addTest(loader.loadTestsFromModule(test_01_register))
# suite.addTest(loader.loadTestsFromModule(test_02_login))
# 使用discover来加载用例模块
# 第一个参数为查询用例模块所在的目录路径, 第二个参数为通配符(跟shell中类似)
suite = unittest.defaultTestLoader.discover(CASES_DIR)
result_full_path = do_yaml.read('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 fb:
# 创建测试运行程序
runner = HTMLTestRunner(stream=fb,
title=do_yaml.read('report', 'title'),
description=do_yaml.read('report', 'description'),
tester=do_yaml.read('report', 'tester'))
# 执行测试套件中的用例
runner.run(suite)
def setUpClass(cls):
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.read('api', 'version'))
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 setUpClass(cls):
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.read('api',
'version')) # 添加公共的请求头, url版本号
def setUpClass(cls) -> None: #所有用例执行前会被调用一次
# 创建请求对象
cls.do_request = HandleRequest()
# 添加公共请求头
cls.do_request.add_headers(do_yaml.read("api", "version"))
def setUpClass(cls):
cls.do_request = HandleRequest()
api_version = do_yaml.read("api", "version")
cls.do_request.add_headers(api_version)
cls.do_mysql = HandleMysql()
