def __init__(self, name=None):
# 1、创建Logger对象
# 相当于日志记录工具
if name is None:
self.my_logger = logging.getLogger("testcase")
else:
self.my_logger = logging.getLogger(name)
# 2、设置日志器的日志等级
# self.my_logger.setLevel("DEBUG")
self.my_logger.setLevel(do_yaml.get_data("log", "logger_level"))
# 3、创建日志输出渠道（日志显示的地方）
console_handler = logging.StreamHandler()
console_handler.setLevel("WARNING")
# file_handler = logging.FileHandler("testcase.log", encoding="utf-8")
# file_handler = logging.FileHandler(do_yaml.get_data("log", "log_filename"), encoding="utf-8")
log_full_path = os.path.join(LOG_PATH,
do_yaml.get_data("log", "log_filename"))
file_handler = logging.FileHandler(log_full_path, encoding="utf-8")
# 4、创建日志的显示样式（格式）并与渠道进行关联
formater = logging.Formatter(
'%(asctime)s - [%(levelname)s] - [msg]: %(message)s - %(name)s - %(lineno)d'
)
console_handler.setFormatter(formater)
file_handler.setFormatter(formater)
# 5、日志器对象与日志输出渠道（展示的地方）进行关联
self.my_logger.addHandler(console_handler)
self.my_logger.addHandler(file_handler)
def __init__(self):
self.conn = pymysql.connect(
host=do_yaml.get_data('mysql', 'host'),
user=do_yaml.get_data('mysql', 'user'),
password=do_yaml.get_data('mysql', 'password'),
db=do_yaml.get_data('mysql', 'db'),
port=do_yaml.get_data('mysql', 'port'),
charset='utf8', # 这里只能写为utf8
cursorclass=pymysql.cursors.DictCursor)
self.cursor = self.conn.cursor()
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 to_encrypt(cls, msg, pub_key=None):
"""
非对称加密
:param msg: 待加密字符串或者字节
:param pub_key: 公钥
:return: 密文
"""
if isinstance(msg, str): # 如果msg为字符串, 则转化为字节类型
msg = msg.encode('utf-8')
elif isinstance(msg, bytes): # 如果msg为字节类型, 则无需处理
pass
else: # 否则抛出异常
raise TypeError('msg必须为字符串或者字节类型!')
if not pub_key: # 如果pub_key为空, 则使用全局公钥
# 获取公钥文件名
public_key_filename = do_yaml.get_data("api", "public_key_filename")
# 获取公钥文件所在路径
public_key_path = os.path.join(CONF_PATH, public_key_filename)
with open(public_key_path, 'rb') as file: # 读取公钥
pub_key = file.read()
elif isinstance(pub_key, str): # 如果pub_key为字符串, 则转化为字节类型
pub_key = pub_key.encode('utf-8')
elif isinstance(pub_key, bytes): # 如果msg为字节类型, 则无需处理
pass
else: # 否则抛出异常
raise TypeError('pub_key必须为None、字符串或者字节类型!')
public_key_obj = rsa.PublicKey.load_pkcs1_openssl_pem(pub_key) # 创建 PublicKey 对象
cryto_msg = rsa.encrypt(msg, public_key_obj) # 生成加密文本
cipher_base64 = base64.b64encode(cryto_msg) # 将加密文本转化为 base64 编码
return cipher_base64.decode() # 将字节类型的 base64 编码转化为字符串类型
def test_add(self, one_testcase):
# 将excel中读取的请求参数进行参数化
new_data = Parameterize.to_parma(one_testcase.data)
# 拼接请求URL地址
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行加标
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"), one_testcase.name)
except AssertionError as e:
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
# 再次抛出异常
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = res.json()["data"]["token_info"]["token"]
# add_headers需要传字典类型
# self.do_request.add_headers("Authorization", f"Bearer {token}")
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
self.do_excel.write_data(one_testcase, res.text, "成功")
def setUpClass(cls):
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
cls.do_mysql = HandleMysql()
# cls.do_mysql.create_not_existed_mobile()
do_log.info("开始执行用例")
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, "成功")
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, "成功")
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):
# 构造请求参数
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.get_data(
"api", "api_version")) # 添加请求头到公共请求头
do_log.info("开始执行用例")
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 test_recharge(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
# 1、在充值之前，查询当前用例的金额
# 在发起请求之前, 查询当前账户金额
check_sql = one_testcase.check_sql
if check_sql:
# 参数化excel中check_sql列中的值，check_sql列存放的是一条查询语句
check_sql = Parameterize.to_parma(check_sql)
# 使用check_sql列中的查询语句，查寻数据库中的值，返回的是一个字典
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_before = float(mysql_data['leave_amount']
) # 不是float浮点数, 也不是int类型, 是decimal数据类型
# 2、进行充值
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# one_testcase.expected_value为int类型，需要转化为字符串类型
# self.assertIn(one_testcase.expected_value,
# res.text,
# one_testcase.name)
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"), one_testcase.name)
# 3、查询充值成功之后的金额
# 如果check_sql不为空, 说明要进行数据校验
if check_sql:
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_after = float(mysql_data['leave_amount'])
one_dict = json.loads(new_data, encoding='utf-8')
currrent_recharge_amount = one_dict['amount']
actual_amount = amount_before + currrent_recharge_amount
self.assertEqual(actual_amount,
amount_after,
msg="数据库中充值的金额有误")
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = actual_value["data"]["token_info"]["token"]
# add_headers需要传字典类型
# self.do_request.add_headers("Authorization", f"Bearer {token}")
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
self.do_excel.write_data(one_testcase, res.text, "成功")
def 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("开始执行用例")
def is_existed_mobile(self, mobile):
"""
判断指定的手机号在数据库中是否存在
:param mobile: 11位手机号组成的字符串
:return: True or False
"""
# sql = "SELECT mobile_phone FROM member WHERE mobile_phone=%s;"
sql = do_yaml.get_data('mysql', 'select_user_sql')
if self.get_one_value(sql, args=[mobile]): # 手机号已经存在，则返回True，否则返回False
return True
else:
return False
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, "成功")
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 创建HandleMysql对象
cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id())
do_log.info("开始执行用例")
def test_invest(self, one_testcase):
# 将excel中读取的请求参数进行参数化
new_data = Parameterize.to_parma(one_testcase.data)
# 拼接请求URL地址
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行投资
res = self.do_request.send(one_testcase.method,
new_url,
json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"),
one_testcase.name)
except AssertionError as e:
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = res.json()["data"]["token_info"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
check_sql_str = one_testcase.check_sql
if check_sql_str:
# 将check_sql json格式的字符串转化为字典
check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
if 'loan_id' in check_sql_dict:
# 获取查询loan id的sql语句
loan_id_sql = check_sql_dict.get('loan_id')
# 将sql语句进行参数化
loan_id_sql = Parameterize.to_parma(loan_id_sql)
mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
load_id = mysql_data['id'] # 获取loan_id
# 设置loan_id为GlobalData的类属性
setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
def test_invest(self, one_testcase):
if 8 >= one_testcase.id >= 3:
self.do_request.get_ids()
elif 22 >= one_testcase.id >= 15:
self.do_request.get_gjids()
elif 38 >= one_testcase.id >= 33:
self.do_request.get_ghxsid()
new_data = Parameterize.to_parma(one_testcase.data)
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行加标
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
self.assertEqual(one_testcase.expected_value,
actual_value.get("errcode"), one_testcase.name)
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token" in res.text and one_testcase.id == 1:
token = res.json()["data"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# check_sql_str = one_testcase.check_sql
# if check_sql_str:
# # 将check_sql json格式的字符串转化为字典
# check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
# if 'loan_id' in check_sql_dict:
# # 获取查询loan id的sql语句
# loan_id_sql = check_sql_dict.get('loan_id')
# # 将sql语句进行参数化
# loan_id_sql = Parameterize.to_parma(loan_id_sql)
# mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
#
# load_id = mysql_data['id'] # 获取loan_id
# # 设置loan_id为GlobalData的类属性
# setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
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, "成功")
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(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, "成功")
def create_user(reg_name, password=12345678, type=1):
"""
创建用户并将用户信息，添加至全局数据池中
:param reg_name: 用户昵称
:param password: 用户密码，默认为12345678
:param type: 用户类型，默认为1，普通用户
:return:
"""
do_request = HandleRequest()
do_mysql = HandleMysql()
# 获取未注册手机号
mobile_phone = do_mysql.create_not_existed_mobile()
# 构造请求参数
param = {
"mobile_phone": mobile_phone,
"pwd": password,
"reg_name": reg_name,
"type": type
}
# 构造请求url路径
url = "http://api.lemonban.com/futureloan/member/register"
# 获取api头信息
do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 进行注册
res = do_request.send("POST", url, json=param)
# sql = do_yaml.get_data("mysql", "select_user_sql")
# do_mysql.get_values(sql, )
# 从响应报文中获取用户id
user_id = res.json()["data"]["id"]
# 关闭相关连接
do_request.close()
do_mysql.close()
# 将用户信息添加至全局数据池中
setattr(GlobalData, "${" + reg_name + "_user_tel}", mobile_phone)
setattr(GlobalData, "${" + reg_name + "_user_pwd}", password)
setattr(GlobalData, "${" + reg_name + "_user_id}", user_id)
class TestAdd(unittest.TestCase):
# 创建handleexcel对象
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "add")
testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表
@classmethod
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 创建HandleMysql对象
cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_id}",
cls.do_mysql.get_not_existed_user_id())
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
# 关闭连接
cls.do_mysql.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_add(self, one_testcase):
# 将excel中读取的请求参数进行参数化
new_data = Parameterize.to_parma(one_testcase.data)
# 拼接请求URL地址
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行加标
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"), one_testcase.name)
except AssertionError as e:
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
# 再次抛出异常
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = res.json()["data"]["token_info"]["token"]
# add_headers需要传字典类型
# self.do_request.add_headers("Authorization", f"Bearer {token}")
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
self.do_excel.write_data(one_testcase, res.text, "成功")
class TestInvest(unittest.TestCase):
"""
投资接口测试类
"""
# 创建handleexcel对象
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "invest")
testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表
@classmethod
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 创建HandleMysql对象
cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id())
# 创建一个不存在的loan id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_loan_id}", cls.do_mysql.get_not_existed_loan_id())
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
# 关闭连接
cls.do_mysql.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_invest(self, one_testcase):
# 将excel中读取的请求参数进行参数化
new_data = Parameterize.to_parma(one_testcase.data)
# 拼接请求URL地址
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行投资
res = self.do_request.send(one_testcase.method,
new_url,
json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"),
one_testcase.name)
except AssertionError as e:
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = res.json()["data"]["token_info"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
check_sql_str = one_testcase.check_sql
if check_sql_str:
# 将check_sql json格式的字符串转化为字典
check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
if 'loan_id' in check_sql_dict:
# 获取查询loan id的sql语句
loan_id_sql = check_sql_dict.get('loan_id')
# 将sql语句进行参数化
loan_id_sql = Parameterize.to_parma(loan_id_sql)
mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
load_id = mysql_data['id'] # 获取loan_id
# 设置loan_id为GlobalData的类属性
setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRecharge(unittest.TestCase):
# 创建handleexcel对象
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "recharge")
testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表
@classmethod
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 创建HandleMysql对象
cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_id}",
cls.do_mysql.get_not_existed_user_id())
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
# 释放资源
cls.do_request.close()
# 关闭连接
cls.do_mysql.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_recharge(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
# 1、在充值之前，查询当前用例的金额
# 在发起请求之前, 查询当前账户金额
check_sql = one_testcase.check_sql
if check_sql:
# 参数化excel中check_sql列中的值，check_sql列存放的是一条查询语句
check_sql = Parameterize.to_parma(check_sql)
# 使用check_sql列中的查询语句，查寻数据库中的值，返回的是一个字典
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_before = float(mysql_data['leave_amount']
) # 不是float浮点数, 也不是int类型, 是decimal数据类型
# 2、进行充值
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# one_testcase.expected_value为int类型，需要转化为字符串类型
# self.assertIn(one_testcase.expected_value,
# res.text,
# one_testcase.name)
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"), one_testcase.name)
# 3、查询充值成功之后的金额
# 如果check_sql不为空, 说明要进行数据校验
if check_sql:
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_after = float(mysql_data['leave_amount'])
one_dict = json.loads(new_data, encoding='utf-8')
currrent_recharge_amount = one_dict['amount']
actual_amount = amount_before + currrent_recharge_amount
self.assertEqual(actual_amount,
amount_after,
msg="数据库中充值的金额有误")
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = actual_value["data"]["token_info"]["token"]
# add_headers需要传字典类型
# self.do_request.add_headers("Authorization", f"Bearer {token}")
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
self.do_excel.write_data(one_testcase, res.text, "成功")
# from HTMLTestRunnerNew import HTMLTestRunner
from libs.HTMLTestRunnerNew import HTMLTestRunner
# from handle_yaml import do_yaml
from scripts.handle_yaml import do_yaml
from scripts.handle_path import CASES_PATH, REPORTS_PATH
from scripts.handle_user import generate_three_user
# 在执行用例之后，先创建三个用户并存放在全局数据池GlobalData中
# generate_three_user()
# suite = unittest.defaultTestLoader.discover(r"C:\Users\KeYou\PycharmProjects\TestApi0509\cases")
suite = unittest.defaultTestLoader.discover(CASES_PATH)
# html_filename = do_yaml.get_data("report", "filename")
# html_filename = r"C:\Users\KeYou\PycharmProjects\TestApi0509\reports" + "\\" + html_filename
# html_filename = os.path.join(REPORTS_PATH, html_filename)
html_filename = do_yaml.get_data('report',
'filename') + '_' + datetime.strftime(
datetime.now(), "%Y%m%d%H%M%S") + ".html"
html_filename = os.path.join(REPORTS_PATH, html_filename)
with open(html_filename, "wb") as file:
runner = HTMLTestRunner(file,
verbosity=do_yaml.get_data("report", "verbosity"),
title=do_yaml.get_data("report", "title"),
description=do_yaml.get_data(
"report", "description"),
tester=do_yaml.get_data("report", "tester"))
runner.run(suite)
def setUpClass(cls):
# 3、构造请求参数
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
do_log.info("开始执行用例")
class TestJingXianSuo(unittest.TestCase):
"""
投资接口测试类
"""
do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "all")
testcases_data = do_excel.read_data() # 嵌套字典的列表
@classmethod
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "headers"))
# 创建HandleMysql对象
# cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
# setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id())
# 创建一个不存在的loan id，并加入到全局数据池中
# setattr(GlobalData, "${not_existed_loan_id}", cls.do_mysql.get_not_existed_loan_id())
do_log.info("开始执行用例")
@classmethod
def tearDownClass(cls):
cls.do_request.close()
# 关闭连接
# cls.do_mysql.close()
do_log.info("用例执行结束")
@ddt.data(*testcases_data)
def test_invest(self, one_testcase):
if 8 >= one_testcase.id >= 3:
self.do_request.get_ids()
elif 22 >= one_testcase.id >= 15:
self.do_request.get_gjids()
elif 38 >= one_testcase.id >= 33:
self.do_request.get_ghxsid()
new_data = Parameterize.to_parma(one_testcase.data)
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行加标
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
self.assertEqual(one_testcase.expected_value,
actual_value.get("errcode"), one_testcase.name)
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token" in res.text and one_testcase.id == 1:
token = res.json()["data"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# check_sql_str = one_testcase.check_sql
# if check_sql_str:
# # 将check_sql json格式的字符串转化为字典
# check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
# if 'loan_id' in check_sql_dict:
# # 获取查询loan id的sql语句
# loan_id_sql = check_sql_dict.get('loan_id')
# # 将sql语句进行参数化
# loan_id_sql = Parameterize.to_parma(loan_id_sql)
# mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
#
# load_id = mysql_data['id'] # 获取loan_id
# # 设置loan_id为GlobalData的类属性
# setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
@Motto: ABC(Always Be Coding) @Email: [email protected] @Company: 湖南省零檬信息技术有限公司 @Copyright: 柠檬班 ------------------------------------------------- """ import os import unittest # from HTMLTestRunnerNew import HTMLTestRunner from libs.HTMLTestRunnerNew import HTMLTestRunner # from handle_yaml import do_yaml from scripts.handle_yaml import do_yaml from scripts.handle_path import CASES_PATH, REPORTS_PATH # suite = unittest.defaultTestLoader.discover(r"C:\Users\KeYou\PycharmProjects\TestApi0509\cases") suite = unittest.defaultTestLoader.discover(CASES_PATH) html_filename = do_yaml.get_data("report", "filename") # html_filename = r"C:\Users\KeYou\PycharmProjects\TestApi0509\reports" + "\\" + html_filename html_filename = os.path.join(REPORTS_PATH, html_filename) with open(html_filename, "wb") as file: runner = HTMLTestRunner(file, verbosity=do_yaml.get_data("report", "verbosity"), title=do_yaml.get_data("report", "title"), description=do_yaml.get_data( "report", "description"), tester=do_yaml.get_data("report", "tester")) runner.run(suite)
import json
import requests
from scripts.handle_yaml import do_yaml
# 获取api版本信息
api_version = do_yaml.get_data("api",
"api_version").get("X-Lemonban-Media-Type")
if api_version == "lemonban.v3": # 如果为v3版本, 才导入HandleSign
from scripts.handle_sign import HandleSign
class HandleRequest:
def __init__(self):
# 创建会话对象
self.session = requests.Session()
def send(self, method, url, **kwargs):
"""
发送请求的方法
:param method: 请求方法
:param url: 请求url
:param kwargs: headers请求头字典, data、json、files
:return:
"""
one_method = method.upper()
kwargs["json"] = self.handle_param("json", kwargs)
kwargs["data"] = self.handle_param("data", kwargs)
if hasattr(self, 'token'
