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 __init__(self):
# 连接数据库
self.con = pymysql.connect(
host=conf.get_str("mysql", "host"),
user=conf.get_str("mysql", "user"),
password=conf.get_str("mysql", "password"),
port=conf.get_int("mysql", "port"), # 获取整数类型用get_int
charset=conf.get_str("mysql", "charset")) # charset：编码方式
# 创建一个游标
self.cur = self.con.cursor()
def test_audit(self, case):
# 拼接完整的接口地址
url = conf.get_str("env", "url_ip") + 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
# ------第二步：发送请求到接口，获取实际结果--------
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"]))
def test_login(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"]:
# 进行替换
test_data_cases["data"] = test_data_cases["data"].replace("#phone#", user) # 替换完后需要接收，不然没有实质的替换
if "#pwd#" in test_data_cases["data"]:
# 进行替换
test_data_cases["data"] = test_data_cases["data"].replace("#pwd#", pwd) # 替换完后需要接收，不然没有实质的替换
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"])
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"]))
def setUpClass(cls):
# -----------在测试用例类执行用例之前先进行登录-->
# 登录，获取用户的id以及鉴权需要用到的token
url = conf.get_str("env", "url_ip") + "/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]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
def setUp(self):
# ---------在测试用例(每个审核的用例)执行之前都加一个项目，将项目id保存起来----------
url = conf.get_str("env", "url_ip") + "/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
}
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))
def replace_data(data):
r = r"#(.+?)#" # 匹配规则
# 判断是否有需要替换的数据
while re.search(r, data): # 如果匹配到有数据，就提取出来
# 匹配出第一个要替换的数据
res = re.search(r, data)
# 提取待替换的内容
item = res.group()
# 获取替换内容的数据项
key = res.group(1)
try:
# 根据替换内容中的数据项去配置文件中找到对应的内容，进行替换
data = data.replace(item, conf.get_str("test_data", key))
except: # 没有可以通过提取的时候，写入配置文件中
# 没有进行替换，替换成
data = data.replace(item, getattr(TestData,
key)) # getattr：动态的获取属性
# 备注：TestData传入类名，key如果没有找到就去类里面获取属性
# 返回替换好的数据
return data # 替换完后，返回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"]))
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"]))
import unittest
from common.read_excel import ReadExcel
from common.contants import data_dir # 用例数据所在的路径
import os
from library.ddt import ddt, data
from common.read_conf import conf # 配置文件解析对象
from common.handle_request import HandleRequest
from common.my_log import my_log # 导入日志
import jsonpath
from common.handle_db import HandleDB
import decimal
# ----------------------修改充值用例类-----------------------------------------
from common.handle_data import TestData, replace_data
data_file_path = os.path.join(data_dir, "test_data.xlsx") # 用例数据的路径
user = conf.get_str("test_data", "user")
pwd = conf.get_str("test_data", "pwd")
"""
setUpClass中提取的用户id和token，如何在用例方法中使用
（1）设为全局变量
（2）保存为类属性：在setUpClass类中，通过加上cls，设置为类属性，测试方法直接通过self调用类属性
（3）写入到配置文件
（4）保存在临时变量的类中(后面会讲的，先不要去研究)
"""
@ddt
class TestRecharge(unittest.TestCase):
# 通过类创建excel对象
excel = ReadExcel(data_file_path, "recharge")
# 读取数据
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"]))
"""
测试用例运行程序的四个步骤：
（1）第一步：创建一个测试套件
（2）第二步：将测试用例，加载到测试套件中
(3)第三步：创建一个测试程序运行程序启动器
(4)第四步：使用启动器去执行测试套件
"""
# 测试用例运行程序
import unittest
import os
from library.HTMLTestRunnerNew import HTMLTestRunner
from common.contants import case_dir # 测试用例模块所在的目录
from common.contants import reports_dir # 测试报告的目录
from common.read_conf import conf # 导入配置文件解释器对象
filename = conf.get_str("report", "filename")
# （1）第一步：创建测试套件
suite = unittest.TestSuite()
# （2）第二步：加载用例到套件中
# ①通过loader去加载
loader = unittest.TestLoader()
# ②往套件里面加载测试用例：通过所在目录路径加载
suite.addTest(loader.discover(case_dir)) # 给一个用例的所在目录的绝对路径
# 备注：加r的目的是防止转义
# (3)第三步：创建一个测试用例运行程序
report_path = os.path.join(reports_dir, filename)
with open(report_path, "wb") as f: # 生成html文件的测试报告
runner = HTMLTestRunner(
stream=f, # 打开一个报告文件，将句柄传给stream
tester="小青年,", # 报告中形式的测试人员，可添加多个
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"]))
