class HandleAssert:
def __init__(self):
self.sql_com_res = {} # 存储sql查询之后的比较结果
self.db = HandleDB() # 打开数据库连接
def assert_sql(self, check_sql_str):
self.get_sql_comp_res(check_sql_str)
# 关闭数据库连接
self.db.close()
if False in self.sql_com_res.values():
logger.error("断言失败，数据库比对不成功！")
raise AssertionError
else:
logger.info("数据库比对成功！")
def get_sql_comp_res(self, check_sql_str):
check_sql_dict = eval(check_sql_str)
logger.info("数据库校验为：\n{}".format(check_sql_dict))
if check_sql_dict["check_type"] == "value":
logger.info("比较sql语句查询结果之后的值")
sql_res = self.db.get_one(check_sql_dict["check_sql"])
logger.info("执行sql：{}".format(check_sql_dict["check_sql"]))
logger.info("查询结果：{}".format(sql_res))
logger.info("预期结果为：{}".format(check_sql_dict["expected"]))
# 执行的结果进行比较。sql_res为字典类型
for key, value in check_sql_dict["expected"].items():
if key in sql_res.keys():
if isinstance(sql_res[key], Decimal):
sql_res[key] = float(sql_res[key])
logger.info("将Decimal转换为float后的值：{}".format(sql_res[key]))
if value == sql_res[key]:
self.sql_com_res[key] = True # 比较成功 存储到sql_com_res中
logger.info("比较成功！")
else:
self.sql_com_res[key] = False # 比较失败 存储到sql_com_res中
logger.info("比较失败！")
else:
logger.info("sql查询结果里面没有对应的列名{}，请检查预期结果或查询语句是否正确}".format(key))
# 比对slq语句查询之后的条数
elif check_sql_dict["check_type"] == "count":
logger.info("比较sql语句查询之后的条数，sql查询结果为整数，只要比对数字即可！")
sql_res = self.db.get_count(check_sql_dict["check_sql"])
logger.info("执行sql：{}".format(["check_sql"]))
logger.info("查询结果：{}".format(sql_res))
logger.info("预期结果为：{}".format(check_sql_dict["expected"]))
# 比对
if sql_res == check_sql_dict["expected"]:
self.sql_com_res["count"] = True
logger.info("比较成功！")
else:
self.sql_com_res["count"] = False
logger.info("比较失败！")
def get_new_phone():
# 判断手机号是否已经注册，如果已经注册，重新生成新的手机号码
while True:
phone = __gen_phone()
# 向数据库查询手机号是否已存在，如果查询结果为0，则为未注册，return退出循环
hd = HandleDB()
select_sql = f"select * from member where mobile_phone={phone};"
count = hd.get_count(select_sql)
if count == 0:
hd.close()
return phone
def new_phone():
db = HandleDB()
while True:
phone = __get_phone()
# 校验数据库
count = db.get_sql(
"select * from member where mobile_phone={}".format(phone))
if count == 0:
db.close()
return phone
def setUpClass(cls):
# 创建操作数据库的对象
cls.db = HandleDB()
# 登录，获取用户的id以及鉴权需要用到的token
url = conf.get_str("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get_str("test_data", 'user'),
"pwd": conf.get_str("test_data", "pwd")
}
headers = eval(conf.get_str("env", "headers"))
response = cls.http.send(url=url,
method="post",
json=data,
headers=headers)
json_data = response.json()
# -------登录之后，从响应结果中提取用户id和token-------------
# 1、提取用户id
member_id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "member_id", str(member_id))
# 2、提取token
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
setattr(TestData, "token", token)
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
class TestWithdraw(unittest.TestCase):
excel = ReadExcel(data_file_path, "withdraw")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_withdraw(self, case):
# 第一步：准备测试用例数据
url = conf.get_str("env", "url") + case["url"]
data = eval(replace_data(case["data"]))
method = case["method"]
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
expected = eval(case["expected"])
row = case["case_id"] + 1
if case["check_sql"]:
sql = replace_data(case["check_sql"])
start_money = self.db.get_one(sql)[0]
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = res.json()
if case["interface"] == "login":
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "member_id", str(id))
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token", token)
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_money = self.db.get_one(sql)[0]
withdraw_money = decimal.Decimal(str(data["amount"]))
my_log.info("取现之前金额为:{}\n取现金额为:{}\n取现之后金额为:{}".format(
start_money, withdraw_money, end_money))
self.assertEqual(withdraw_money, start_money - end_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestAdd(unittest.TestCase):
excel = ReadExcel(file_path, "add")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_add(self, case):
# 第一步：准备用例数据
# 获取url
url = conf.get_str("env", "url") + case["url"]
# 获取数据
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 预期结果
expected = eval(case["expected"])
# 请求方法
method = case["method"]
# 用例所在的行
row = case["case_id"] + 1
# 第二步：发送请求
print(url, method, data, headers)
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
json_data = res.json()
print("json_data=", json_data)
if case["interface"] == "login":
# 如果是登录的用例，提取对应的token,和用户id,保存为TestData这个类的类属性，用来给后面的用例替换
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "admin_member_id", str(id))
# 第三步：断言
try:
self.assertEqual(expected["code"], json_data["code"])
self.assertEqual(expected["msg"], json_data["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(json_data))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestAdd(unittest.TestCase):
excel = ReadExcel(file_path, "add")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_add(self, case):
# 第一步：准备用例数据
url = conf.get_str("env", "url") + case["url"]
case["data"] = replace_data(case["data"])
data = eval(case["data"])
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
expected = eval(case["expected"])
method = case["method"]
row = case["case_id"] + 1
# 第二步：发送请求
if case["check_sql"]:
sql = replace_data(case["check_sql"])
s_loan_num = self.db.count(sql)
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = res.json()
if case["interface"] == "login":
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "admin_member_id", str(id))
# 第三步：比对结果（断言）
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_loan_num = self.db.count(sql)
self.assertEqual(end_loan_num - s_loan_num, 1)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestAdd(unittest.TestCase):
excel = ReadExcel(data_file_path, "add")
# 读取数据
test_data = excel.read_excel()
# # 创建http对象
http = HandleRequest()
#创建db对象
db = HandleDB()
@data(*test_data)
def test_add(self, test_data_cases):
# 第一步：准备用例数据
# (1)获取url
url = conf.get_str("env", "url_ip") + test_data_cases["url"]
# （2）获取数据
test_data_cases["data"] = replace_data(
test_data_cases["data"]) # 调用replace_data方法
# （3）数据转换
data = eval(test_data_cases["data"])
# (4)预期结果
expected = eval(test_data_cases["expected"]) # excel是字典类型，需要转换一下
# （5）请求方法
method = test_data_cases["method"]
# （6）用例所在的行
row = test_data_cases["case_id"] + 1
# （7）请求头
headers = eval(conf.get_str("env", "headers"))
if test_data_cases["interface"] != "login":
# 如果不是token，需要添加请求头
headers["Authorization"] = getattr(TestData,
"token_data") # 调用保存在临时变量的类中
#先判断check_sql是否有数据
if test_data_cases["check_sql"]:
sql = replace_data(
test_data_cases["check_sql"]) #先获取check_sql数据，在进行替换
#执行sql语句
s_loan_num = self.db.count(sql) #得到加标前项目的条数
# 第二步：发送请求到接口，获取实际结果
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = res.json()
# 判断是否是登录用例，是的话，则提取token
if test_data_cases["interface"] == "login":
# 如果是登录的用例，提取对应的token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
# 通过setattr方法保存到TestData类里面
setattr(TestData, "token_data", token_data)
# 提取member_id
admin_member_id = jsonpath.jsonpath(result, "$..id")[0]
# 通过setattr方法保存到TestData类里面
setattr(TestData, "admin_member_id",
str(admin_member_id)) # 存类属性的时候，需要与excel中的参数名一致
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
# 加标后，项目的条数
# 先判断check_sql是否有数据
if test_data_cases["check_sql"]:
sql = replace_data(
test_data_cases["check_sql"]) # 先获取check_sql数据，在进行替换
# 执行sql语句
end_loan_num = self.db.count(sql) # 得到加标前项目的条数
self.assertEqual(end_loan_num - s_loan_num, 1)
except AssertionError as e:
self.excel.write_data(row=row, column=8,
value="未通过") # 可以把列(column)放在配置文件里面
# 记录没有通过的日志
my_log.info("用例：{}------>执行未通过".format(test_data_cases["title"]))
# 在没有通过的时候，使用print会打印在测试报告中
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
# 在没有通过的时候，将print输出到日志里面
my_log.info("预期结果：{}".format(expected))
my_log.info("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8,
value="通过") # 可以把列(column)放在配置文件里面
# 记录通过的日志
my_log.info("用例：{}------>执行通过".format(test_data_cases["title"]))
class TestAdd(unittest.TestCase):
excel = ReadExcel(file_path, "add")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_add(self, case):
#--------------第一步：准备用例数据-----------------
#1.获取url
url = conf.get_str("env", "url") + case["url"]
#2.获取数据
case["data"] = replace_data(case["data"])
data = eval(case["data"])
#3.获取请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
#预期结果
expected = eval(case["expected"])
#请求方法
method = case["method"]
print(method, type(method))
#用例所在行
row = case["case_id"] + 1
#----------------第二步：发送请求---------------------
if case["check_sql"]:
sql = replace_data(case["check_sql"])
s_loan_num = self.db.count(sql)
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
json_data = res.json()
if case["interface"] == "login":
# 如果是登录的用例，提取对应的token,和用户id,保存为TestData这个类的类属性，用来给后面的用例替换
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "admin_member_id", str(id))
'''补充知识：
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
setattr(object, name, value),有就用新的属性值替换掉原来的，没有就自动创建一个属性值
>>>class A(object):
>>> bar = 1
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5) # 设置属性 bar 值
>>> a.bar
5
'''
#----------------第三步：断言-------------------------------
try:
self.assertEqual(expected["code"], json_data["code"])
self.assertEqual(expected["msg"], json_data["msg"])
# 判断是否需要sql校验
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_loan_num = self.db.count(sql)
self.assertEqual(end_loan_num - s_loan_num, 1)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(json_data))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestRecharge(unittest.TestCase):
# 通过类创建excel对象
excel = ReadExcel(data_file_path, "recharge")
# 读取数据
test_data = excel.read_excel()
http = HandleRequest()
# 创建DB对象
db = HandleDB()
@classmethod
def setUpClass(cls): # 在测试用例类(TestRecharge)执行之前就会执行这个方法
# 登录：获取用户的id以及鉴权需要用到的token
url = conf.get_str("env", "url_ip") + "/member/login"
login_data = {"mobile_phone": user, "pwd": pwd}
headers = eval(conf.get_str("env", "headers"))
response = cls.http.send(
url=url, method="post", json=login_data,
headers=headers) # 此处用cls是因为是类方法setUpClass(cls)里面的，是通过类属性去调用的
result = response.json()
# 登录之后，从响应结果中提取用户id和token
# （1）获取用户id
# cls.member_id = str(jsonpath.jsonpath(result, "$..id")[0])#设置为TestRecharge类的类属性
member_id = jsonpath.jsonpath(result, "$..id")[0] # 获取member_id
print(member_id)
# 设置TestData类的类属性
setattr(
TestData, "member_id",
str(member_id)) #设置TestData类的类属性,设置类属性为member_id，类属性的值为member_id
# （2）提取token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
# cls.token_data = token_type + " " + token#设置为TestRecharge类的类属性
token_data = token_type + " " + token #
setattr(
TestData, "token_data",
token_data) # 设置TestData类的类属性,设置类属性为token_data，类属性的值为token_data
# def setUp(self):#每个用例执行之前都会执行
# 如果把登录放在这里，每执行完一个用例就会登录，增加代码的运行时间，没有必要
@data(*test_data) # 进行解包
def test_recharge(self, test_data_cases):
# 第一步：准备用例数据
# 备注：列表、字典方式存储的，excel读取出来是字符串。数值类型，读取出来是数值类型的，字符串类型，读取出来是字符串类型。
# ①拼接完整的接口地址
url = conf.get_str("env", "url_ip") + test_data_cases["url"]
# ②请求的方法
method = test_data_cases["method"]
# ③请求参数
# 判断是否有用户id需要替换
# if "#member_id#" in test_data_cases["data"]:
# # 进行替换
# test_data_cases["data"] = test_data_cases["data"].replace("#member_id#",
# self.member_id) # 替换完后需要接收，不然没有实质的替换
test_data_cases["data"] = replace_data(
test_data_cases["data"]) #调用replace_data方法
data = eval(test_data_cases["data"])
# ④请求头
headers = eval(conf.get_str("env", "headers"))
# 添加鉴权
# headers["Authorization"] = self.token_data
# 从TestData类里面获取token_data属性：两种方法
# headers["Authorization"] = TestData.token_data#方法一：直接从TestData类里面获取token_data属性
headers["Authorization"] = getattr(
TestData, "token_data") # 方法二：用getattr获取TestData类里面获取token_data属性
# ⑤预期结果
expected = eval(test_data_cases["expected"])
# ⑥该用例在表单中所在行
row = test_data_cases["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
if test_data_cases[
"check_sql"]: # 先判断用例里面check_sql字段是否有数据，如果有数据，说明需要进行数据库校验
sql = test_data_cases["check_sql"].format(user)
# 获取充值之前的余额
start_money = self.db.get_one(sql)[0]
response = HandleRequest().send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
# 充值后，进行数据库校验
if test_data_cases["check_sql"]:
sql = test_data_cases["check_sql"].format(user)
# 获取充值之后的余额
end_money = self.db.get_one(sql)[0]
# 获取请求参数里面的充值金额
recharge_money = decimal.Decimal(str(data["amount"]))
my_log.info("充值之前金额为：{}\n，充值金额为：{}\n，充值之后金额为：{}\n".format(
start_money, recharge_money, end_money))
# 进行断言
self.assertEqual(recharge_money, end_money - start_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8,
value="未通过") # 可以把列(column)放在配置文件里面
# 记录没有通过的日志
my_log.info("用例：{}------>执行未通过".format(test_data_cases["title"]))
# 在没有通过的时候，使用print会打印在测试报告中
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
# 在没有通过的时候，将print输出到日志里面
my_log.info("预期结果：{}".format(expected))
my_log.info("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8,
value="通过") # 可以把列(column)放在配置文件里面
# 记录通过的日志
my_log.info("用例：{}------>执行通过".format(test_data_cases["title"]))
'''
作者：seak
时间：
项目：
题目：
作用：
备注：
'''
import decimal
from common.handle_db import HandleDB
from common.myconfig import conf
#调用数据库控制类
db = HandleDB()
#输入查询语句
sql = 'SELECT leave_amount FROM futureloan.member WHERE mobile_phone="{}"'
#调用配置文件中user的手机号码
phone = conf.get_str("test_data", 'user')
#获取这个电话号码所拥有的金额，格式化sql语句
s_amount = db.get_one(sql.format(phone))[0]
print(s_amount, type(s_amount))
#decimal的类型不能与float相加，所以要进行转化,将其他数据转化为decimal问题，转化之前线转化成字符串否者会有精度问题
amount = 100.1
amount = decimal.Decimal(str(amount))
all_amount = s_amount + amount
print(all_amount)
def __init__(self):
self.sql_com_res = {} # 存储sql查询之后的比较结果
self.db = HandleDB() # 打开数据库连接
class TestRegister(unittest.TestCase):
excel = ReadExcel(data_file_path,"register")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_register(self,case):
# 第一步：准备测试用例数据
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求方法
method = case["method"]
# 请求参数
# 判断是否有手机号码需要替换
if "#phone#" in case["data"]:
while True:
phone = self.random_phone()
sql = "SELECT * FROM futureloan.member where mobile_phone={}".format(phone)
count = self.db.count(sql)
if count != 1:
break
case["data"] = case["data"].replace("#phone#",phone)
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 该用例在该表单中所在行
row = case["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if result["msg"] == "OK":
# 去数据库查询当前注册的账号是否存在
sql = "SELECT * FROM futureloan.member where mobile_phone={}".format(phone)
# 获取数据库中有没有该用户的信息
count = self.db.count(sql)
self.assertEqual(1,count)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
@staticmethod
def random_phone():
phone = "133"
for i in range(8):
phone += str(random.randint(0, 9))
return phone
@classmethod
def tearDownClass(cls):
# 关闭数据的连接和游标对象
cls.db.close()
class TestRegister(unittest.TestCase):
excel = ReadExcel(data_file_path, "register")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_register(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 判断是否有有手机号码需要替换
if "#phone#" in case["data"]:
# 生成一个手机号码
phone = self.random_phone()
# 进行替换
case["data"] = case["data"].replace("#phone#", phone)
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# --------------------以下内容为扩展内容----------------
# 先判断是否注册成功，如果是注册成功
# self.phone = "注册成功的手机号码" # 没有注册成功就设置未None
# ---------------------------------------------------
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual((expected["msg"]), result["msg"])
if result["msg"] == "OK":
# 去数据库查询当前注册的账号是否存在
sql = "SELECT * FROM futureloan.member where mobile_phone={}".format(phone)
# 获取数据库中没有没有该用户的信息
count = self.db.count(sql)
# 数据库中返回的数据做断言，判断是否有一条数据
self.assertEqual(1, count)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
@staticmethod
def random_phone():
"""生成随机的手机号码"""
phone = "133"
for i in range(8):
phone += str(random.randint(0, 9))
return phone
@classmethod
def tearDownClass(cls):
# 关闭数据的连接和游标对象
cls.db.close()
class TestAudit(unittest.TestCase):
excel = ReadExcel(file_path, "audit")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@classmethod
def setUpClass(cls):
# -----------执行用例之前先进行登录-->
# 登录，获取用户的id以及鉴权需要用到的token
url = conf.get_str("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get_str("test_data", 'admin_phone'),
"pwd": conf.get_str("test_data", "admin_pwd")
}
headers = eval(conf.get_str("env", "headers"))
response = cls.http.send(url=url, method="post", json=data, headers=headers)
json_data = response.json()
# -------登录之后，从响应结果中提取用户id和token-------------
# 1、提取用户id
member_id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "member_id", str(member_id))
# 2、提取token
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
setattr(TestData, "token", token)
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
def setUp(self):
# ---------每个审核的用例执行之前都加一个项目，将项目id保存起来----------
url = conf.get_str("env", "url") + "/loan/add"
data = {"member_id": getattr(TestData, "member_id"),
"title": "借钱实现财富自由",
"amount": 2000,
"loan_rate": 12.0,
"loan_term": 3,
"loan_date_type": 1,
"bidding_days": 5}
# 获取sign和时间戳
sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
# 将sign加入到请求参数中
data.update(sign_data)
headers = eval(conf.get_str("env", "headers"))
headers["Authorization"] = getattr(TestData, "token_data")
# 发送请求加标
response = self.http.send(url=url, method="post", json=data, headers=headers)
json_data = response.json()
# 1、提取标id
loan_id = jsonpath.jsonpath(json_data, "$..id")[0]
# 2、保存为TestDate的属性
setattr(TestData, "loan_id", str(loan_id))
@data(*cases)
def test_audit(self, case):
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 替换用例参数
case["data.txt"] = replace_data(case["data.txt"])
data = eval(case["data.txt"])
# 获取sign和时间戳
sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
# 将sign加入到请求参数中
data.update(sign_data)
# 请求头
headers = eval(conf.get_str("env", "headers"))
headers["Authorization"] = getattr(TestData, "token_data")
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# 如果审核通过的项目返回ok，说明该项目已审核
if case["title"] == "审核通过" and result["msg"] == "OK":
pass_loan_id = getattr(TestData, "loan_id")
# 将该项目的id保存起来
setattr(TestData, "pass_loan_id", pass_loan_id)
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual((expected["msg"]), result["msg"])
if case["check_sql"]:
sql = replace_data(case["check_sql"])
# 获取这个标的用户id
status = self.db.get_one(sql)[0]
# 进行断言
self.assertEqual(expected["status"], status)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestInvest(unittest.TestCase):
excel = ReadExcel(data_file_path, "invest")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_invest(self, case):
# 第一步：准备用例数据
# 获取URL
url = conf.get_str("env", "url") + case["url"]
# 获取请求的方法
method = case["method"]
# 获取请求的参数
# 替换用例参数
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 获取请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 添加请求头中的token
# 预期结果
expected = eval(case["expected"])
# 获取所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url,
method=method,
headers=headers,
json=data)
result = response.json()
if case["interface"] == "login":
# 提取用户id和token
id = jsonpath.jsonpath(result, "$..id")[0]
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
setattr(TestData, "member_id", str(id))
elif case["interface"] == "add":
# 提取项目id
loan_id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "loan_id", str(loan_id))
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
# 判断是否需要sql校验
if case["check_sql"]:
sql = replace_data(case["check_sql"])
count = self.db.count(sql)[0]
# 判断数据库表中是否有一条新数据
self.assertEqual(1, count)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info(my_log.info("用例：{}--->执行通过".format(case["title"])))
def setUp(cls) -> None:
cls.hr = HandleRequests()
cls.hd = HandleDB()
class TestRegister(unittest.TestCase):
# 通过类创建excel对象
excel = ReadExcel(data_file_path, "register")
# 读取数据
test_data = excel.read_excel()
#创建DB对象
db = HandleDB()
@data(*test_data) # 进行解包
def test_register(self, test_data_cases):
# 第一步：准备用例数据
# 备注：列表、字典方式存储的，excel读取出来是字符串。数值类型，读取出来是数值类型的，字符串类型，读取出来是字符串类型。
# ①拼接完整的接口地址
url = conf.get_str("env", "url_ip") + test_data_cases["url"]
# ②请求的方法
method = test_data_cases["method"]
# ③请求参数
#判断是否有手机号需要替换
if "#phone#" in test_data_cases["data"]:
#生成一个手机号码
phone = self.random_phone()
#进行替换
test_data_cases["data"] = test_data_cases["data"].replace(
"#phone#", phone) # 替换完后需要接收，不然没有实质的替换
data = eval(test_data_cases["data"])
# ④请求头
headers = eval(conf.get_str("env", "headers"))
# ⑤预期结果
expected = eval(test_data_cases["expected"])
# ⑥该用例在表单中所在行
row = test_data_cases["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
response = HandleRequest().send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if result["msg"] == "OK":
#如果注册成功，去数据库查询当前注册的账号是否存在
sql = "select * from futureloan.member where mobile_phone={}".format(
phone)
#获取数据库中有没有该用户的信息：通过db对象，然后调用count方法
count = self.db.count(sql) #查找的结果
#数据库中返回的数据做断言，判断是否有一条数据
self.assertEqual(1, count)
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
except AssertionError as e:
self.excel.write_data(row=row, column=8,
value="未通过") # 可以把列(column)放在配置文件里面
# 记录没有通过的日志
my_log.info("用例：{}------>执行未通过".format(test_data_cases["title"]))
# 在没有通过的时候，使用print会打印在测试报告中
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
# 在没有通过的时候，将print输出到日志里面
my_log.info("预期结果：{}".format(expected))
my_log.info("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8,
value="通过") # 可以把列(column)放在配置文件里面
# 记录通过的日志
my_log.info("用例：{}------>执行通过".format(test_data_cases["title"]))
@staticmethod
def random_phone():
# 生成随机的手机号码
phone = "136"
for i in range(8): # 遍历8次
phone += str(random.randint(0, 9)) # 每次生成转换为字符串，再与phone进行拼接
return phone
@classmethod
#所有用例执行完后，再执行
def tearDownClass(cls):
#关闭数据库的连接和游标对象
cls.db.close()
class TestRecharge(unittest.TestCase):
excel = ReadExcel(data_file_path, "recharge")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@classmethod
def setUpClass(cls):
# # 创建操作数据库的对象
# cls.db = HandleDB()
# 登录，获取用户的id以及鉴权需要用到的token
url = conf.get_str("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get_str("test_data", 'user'),
"pwd": conf.get_str("test_data", "pwd")
}
headers = eval(conf.get_str("env", "headers"))
response = cls.http.send(url=url,
method="post",
json=data,
headers=headers)
json_data = response.json()
# -------登录之后，从响应结果中提取用户id和token-------------
# 1、用户id
member_id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "member_id", str(member_id))
# 2、提取token
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
@data(*cases)
def test_recharge(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 替换用例参数
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
headers["Authorization"] = getattr(TestData, "token_data")
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
if case["check_sql"]:
sql = case["check_sql"].format(conf.get_str("test_data", "user"))
# 获取充值之前的余额
start_money = self.db.get_one(sql)[0]
response = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual((expected["msg"]), result["msg"])
if case["check_sql"]:
sql = case["check_sql"].format(
conf.get_str("test_data", "user"))
# 获取充值之后的余额
end_money = self.db.get_one(sql)[0]
# 充值的金额
recharge_money = decimal.Decimal(str(data["amount"]))
my_log.info("充值之前金额为{}\n,充值金额:{}\n,充值之后金额为{},".format(
start_money, recharge_money, end_money))
# 数据库中返回的数据做断言，判断是否有一条数据
self.assertEqual(recharge_money, end_money - start_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
@classmethod
def tearDownClass(cls):
# 关闭数据的连接和游标对象
cls.db.close()
class TestRecharge(unittest.TestCase):
excel = ReadExcel(data_file_path,"recharge")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@classmethod
def setUpClass(cls):
# 登录，获取用户id和鉴权需要用到的token
url = conf.get_str("env", "url") + "/member/login"
data = {
"mobile_phone":conf.get_str("test_data","user"),
"pwd":conf.get_str("test_data","pwd")
}
headers = eval(conf.get_str("env","headers"))
response = cls.http.send(url=url,method="post",json=data,headers=headers)
json_data = response.json()
# 登录之后从响应结果中提取用户id和token
# 提取用户id
cls.member_id = jsonpath.jsonpath(json_data,"$..id")[0]
# 提取token
token_type = jsonpath.jsonpath(json_data,"$..token_type")[0]
token = jsonpath.jsonpath(json_data,"$..token")[0]
cls.token_data = token_type + " " + token
cls.leave_amount = jsonpath.jsonpath(json_data,"$..leave_amount")[0]
@data(*cases)
def test_recharge(self,case):
# 第一步：准备测试用例数据
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求方法
method = case["method"]
# 请求参数
# 判断是否有用户id需要替换
if "#member_id#" in case["data"]:
case["data"] = case["data"].replace("#member_id#",str(self.member_id))
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
headers["Authorization"] = self.token_data
# 预期结果
expected = eval(case["expected"])
# 该用例在该表单中所在行
row = case["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if result["msg"] == "OK":
sql = "select leave_amount from futureloan.member where id={}".format(self.member_id)
# 获取数据库中有没有该用户的信息
data = self.db.get_one(sql)
print(data)
# self.assertEqual(1, count)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestWithdraw(unittest.TestCase):
excel = ReadExcel(data_file_path, "withdraw")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@classmethod
def setUpClass(cls):
# 获取登录用户手机号和密码
# cls.mobile_phone = conf.get_str("test_data", 'user')
# cls.pwd = conf.get_str("test_data", "pwd")
pass
@data(*cases)
def test_withdraw(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 判断是否有用户id需要替换
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
# 判断是否需要sql校验
if case["check_sql"]:
sql = case["check_sql"].format(conf.get_str("test_data", 'user'))
# 获取取充值之前的余额
start_money = self.db.get_one(sql)[0]
# 发送请求，获取结果
response = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
if case["interface"] == "login":
# -------如果是登录接口，从响应结果中提取用户id和token-------------
# 1、用户id
member_id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "member_id", str(member_id))
# 2、提取token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
# 下面这行代码和上面哪行代码是一个意思，都是将token设为类属性
setattr(TestData, "token_data", token_data)
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual((expected["msg"]), result["msg"])
# 判断是否需要数据库校验
if case["check_sql"]:
sql = case["check_sql"].format(
conf.get_str("test_data", 'user'))
# 获取取充值之前的余额
end_money = self.db.get_one(sql)[0]
recharge_money = decimal.Decimal(str(data["amount"]))
my_log.info("取现之前金额为{}\n，取现金额为：{}\n，取现之后金额为{}，".format(
start_money, recharge_money, end_money))
# 进行断言(开始的金额减去结束的金额)
self.assertEqual(recharge_money, start_money - end_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestWithdraw(unittest.TestCase):
# 通过类创建excel对象
excel = ReadExcel(data_file_path, "withdraw")
# 读取数据
test_data = excel.read_excel()
http = HandleRequest()
db = HandleDB()
@classmethod
def setUpClass(cls): # 在测试用例类(TestRecharge)执行之前就会执行这个方法
# # 获取登录用户手机号和密码：并保存为类属性
# cls.mobile_phone = conf.get_str("test_data", "user")
# cls.pwd = conf.get_str("test_data", "pwd")
pass
# def setUp(self):#每个用例执行之前都会执行
# 如果把登录放在这里，每执行完一个用例就会登录，增加代码的运行时间，没有必要
@data(*test_data) # 进行解包
def test_withdraw(self, test_data_cases):
# 第一步：准备用例数据
# 备注：列表、字典方式存储的，excel读取出来是字符串。数值类型，读取出来是数值类型的，字符串类型，读取出来是字符串类型。
# ①拼接完整的接口地址
url = conf.get_str("env", "url_ip") + test_data_cases["url"]
# ②请求的方法
method = test_data_cases["method"]
# ③请求参数
#调用replace_data方法进行参数替换
test_data_cases["data"] = replace_data(test_data_cases["data"])
data = eval(test_data_cases["data"])
# ④请求头
headers = eval(conf.get_str("env", "headers"))
# 添加鉴权
# 判断是否为登录接口，不是登录接口，则需要加token值
if test_data_cases["interface"] != "login":
# headers["Authorization"] = self.token_data
headers["Authorization"] = getattr(TestData, "token_data")
# ⑤预期结果
expected = eval(test_data_cases["expected"])
# ⑥该用例在表单中所在行
row = test_data_cases["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
if test_data_cases[
"check_sql"]: # 先判断用例里面check_sql字段是否有数据，如果有数据，说明需要进行数据库校验
sql = test_data_cases["check_sql"].format(
conf.get_str("test_data", "user"))
# 获取充值之前的余额
start_money = self.db.get_one(sql)[0]
response = HandleRequest().send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# 判断是否是登录的用例，如果是登录接口，则去获取用户的id，并设置为类属性
if test_data_cases["interface"] == "login":
# 登录之后，从响应结果中提取用户id和token
# （1）获取用户id
# TestWithdraw.member_id = jsonpath.jsonpath(result, "$..id")[0] # 通过类名.属性名设置类属性
member_id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "member_id", str(
member_id)) #使用setattr设置TestData类，member_id属性，属性值为member_id
# （2）提取token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
# TestWithdraw.token_data = token_type + " " + token# 通过类名.属性名设置类属性
token_data = token_type + " " + token # 通过类名.属性名设置类属性
setattr(
TestData, "token_data",
token_data) # 使用setattr设置TestData类，token_data属性，属性值为token_data
# 设置类属性还可以通过setattr进行设置
# 下面这行代码和上面那行代码是一个意思，都是将token设为类属性
setattr(TestWithdraw, "token_data", token_type + " " + token)
# 第一个参数：类名
# 第二个参数：属性名
# 第三个参数：对应的属性值
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
# 提现后，进行数据库校验
if test_data_cases["check_sql"]:
sql = test_data_cases["check_sql"].format(
conf.get_str("test_data", "user"))
# 获取提现之后的余额
end_money = self.db.get_one(sql)[0]
# 获取请求参数里面的充值金额
recharge_money = decimal.Decimal(str(data["amount"]))
my_log.info("提现之前金额为：{}\n，提现金额为：{}\n，提现之后金额为：{}\n".format(
start_money, recharge_money, end_money))
# 进行断言
self.assertEqual(recharge_money, start_money - end_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8,
value="未通过") # 可以把列(column)放在配置文件里面
# 记录没有通过的日志
my_log.info("用例：{}------>执行未通过".format(test_data_cases["title"]))
# 在没有通过的时候，使用print会打印在测试报告中
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
# 在没有通过的时候，将print输出到日志里面
my_log.info("预期结果：{}".format(expected))
my_log.info("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8,
value="通过") # 可以把列(column)放在配置文件里面
# 记录通过的日志
my_log.info("用例：{}------>执行通过".format(test_data_cases["title"]))
