def test_login(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
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"])
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 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)
def test_add(self, case):
# 第一步：准备用例数据
# 获取url
url = conf.get_str("env", "url") + case["url"]
# url = conf.get_str("env", "url") + case.url
# 获取数据
case["data.txt"] = replace_data(case["data.txt"])
data = eval(case["data.txt"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 获取sign和时间戳
sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
# 将sign加入到请求参数中
data.update(sign_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)
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)
setattr(TestData, "token", token)
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"])
# 判断是否需要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"]))
def test_invest(self, case):
# 第一步：准备用例数据
url = conf.get_str("env", "url") + case["url"]
# 请求参数
case["data.txt"] = replace_data(case["data.txt"])
data = eval(case["data.txt"])
# 请求的方法
method = case["method"]
# 请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 获取sign和时间戳
sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
# 将sign加入到请求参数中
data.update(sign_data)
# 添加请求头中的token
# 预期结果
expected = eval(case["expected"])
# 用例所在行
row = case["case_id"] + 1
# 第二步：发送请求
res = self.http.send(url=url,
json=data,
method=method,
headers=headers)
result = res.json()
if case["interface"] == "login":
# 提取用户id和token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "token", 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校验
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):
yamlpath = os.path.join(DATA_DIR, "login.yml")
data = HandleYaml(yamlpath).read_yaml()
url = conf.get_str("env", "url")
header = eval(conf.get_str("env", "header"))
http = HandleRequest()
res = http.send(method="post", json=data, url=url, headers=header)
token = jsonpath.jsonpath(res.json, "$..token")
yield token
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"]))
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 __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"),
charset="utf8")
# 创建一个游标
self.cur = self.con.cursor()
def test_register(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 判断是否有有手机号码需要替换
if "#phone#" in case["data.txt"]:
# 生成一个手机号码
phone = self.random_phone()
# 进行替换
case["data.txt"] = case["data.txt"].replace("#phone#", phone)
data = eval(case["data.txt"])
# 请求头
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"]))
def __init__(self):
host = conf.get_str("mysql", "host")
user = conf.get_str("mysql", "user")
password = conf.get_str("mysql", "password")
port = conf.get_int("mysql", "port")
self.con = pymysql.connect(host=host,
user=user,
password=password,
port=port,
charset="utf8")
self.cur = self.con.cursor()
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"]))
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"]))
def test_invest(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
# 第二步：发送请求
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, "member_id", str(id))
elif case["interface"] == "add":
# 如果是添加项目，则提取项目id
id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "loan_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"]))
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"]))
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 TestLogin():
yamlpath = os.path.join(DATA_DIR, "login.yml")
datas = HandleYaml(yamlpath).read_yaml()
url = conf.get_str("env", "url") + datas[0]["url"]
header = eval(conf.get_str("env", "header"))
name = [i["name"] for i in datas[1:]]
@log
@pytest.mark.parametrize("data", datas[1:], ids=name)
@allure.feature("登录模块")
def test_login(self, data):
http = HandleRequest()
res = http.send(method="post",
json=data,
url=self.url,
headers=self.header)
assert data["Message"] == res.json()["Message"]
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"]))
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]
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}
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 test_login(self, test_data):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + test_data["url"]
# 请求的方法
method = test_data["method"]
# 请求参数
data = eval(test_data["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
# 预期结果
expected = eval(test_data["expected"])
# 该用例在表单的中所在行
row = test_data["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# -------第三步：比对预期结果和实际结果-----
try:
# 业务码断言
assert expected["code"] == result["code"]
# msg断言
assert expected["msg"] == result["msg"]
except AssertionError as e:
# excel中回写结果
self.excel.write_data(row=row, column=8, value="未通过")
# 记录apicases.xlsx日志
my_log.info("用例：{}--->执行未通过".format(test_data["title"]))
my_log.error(e)
# 报告中打印预期和实际结果
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
# excel中回写结果
self.excel.write_data(row=row, column=8, value="通过")
# 记录日志
my_log.info("用例：{}--->执行通过".format(test_data["title"]))
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))
#提取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 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))
# 返回替换好的数据
return data
import os
import logging
from common.myconfig import conf
from common.contants import LOG_DIR
# 读取配置文件中的数据
level = conf.get_str("logging", "level")
f_level = conf.get_str("logging", "f_level")
s_level = conf.get_str("logging", "s_level")
filename = conf.get_str("logging", "filename")
# 获取日志文件的绝对路径
file_path = os.path.join(LOG_DIR, filename)
class MyLogger(object):
@staticmethod
def create_logger():
# 一、创建一个名为：python的日志收集器
my_log = logging.getLogger("python_api_test")
# 二、设置日志收集器的等级
my_log.setLevel(level)
# 三、添加输出渠道（输出到控制台）
# 1、创建一个输出到控制台的输出渠道
sh = logging.StreamHandler()
# 2、设置输出等级
sh.setLevel(s_level)
# 3、将输出渠道绑定到日志收集器上
my_log.addHandler(sh)
# 四、添加输出渠道（输出到文件）
fh = logging.FileHandler(file_path, encoding="utf8")
fh.setLevel(f_level)
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"]))
# if "#pwd#" in data:
# data = data.replace("#pwd#",conf.get_str("test_data","pwd"))
# print(data)
# ------------使用正则进行替换----方式不通用----------
# data = '{"mobile_phone":"#phone#","pwd":"#pwd#"}'
# # # #两个#号之间可以表示要替换的数据，.+表示1个字符以上,?关闭贪婪模式
# r = "#.+?#"
# res2 = re.findall(r,data)
# print(res2)
#
# #使用search方法，只找第一个
# res3 = re.search(r,data)
# print(res3)
# data = data.replace(res3.group(),conf.get_str("test_data","user"))
# print(data)
#使用通用的方法
data = '{"mobile_phone":"#phone#","pwd":"#pwd#"}'
r = "#(.+?)#"
res = re.search(r,data)
#判断结果是否为None
if res:
item = res.group()#获取全部数据
key = res.group(1)#获取（）组中的数据
print(item)
print(key)
#进行替换，item替换成配置文件conf中test_data,通用key(因为key在前面()组中获取的是phone所以key会替换成phone号码)
data = data.replace(item,conf.get_str("test_data",key))
print(data)
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
# ------第二步：发送请求到接口，获取实际结果--------
#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"])) #decimal只支持整数，如果有小数的话先转化成str就会自动保存1位小数
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"]))
import logging,time
from common.myconfig import conf
from common.contants import LOG_DIR
import os
# 读取配置文件中的数据
level = conf.get_str('logging','level')
f_level = conf.get_str('logging','f_level')
s_level = conf.get_str('logging','s_level')
# filename = conf.get_str('logging','filename')
filename = "{}.log".format(time.strftime("%Y_%m_%d"))
# 获取日志文件的绝对路径
file_path = os.path.join(LOG_DIR, filename)
# print(f_level)
class MyLogger(object):
@staticmethod
def create_logger():
# 一、创建一个名为：python24的日志收集器
my_log = logging.getLogger("python24")
# 二、设置日志收集器的等级
my_log.setLevel(level)
# 三、添加输出渠道（输出到控制台）
# 1、创建一个输出到控制台的输出渠道
sh = logging.StreamHandler()
# 2、设置输出等级
sh.setLevel(s_level)
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"]))
'''
作者：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)
