def test_loan_add(self, item):
rep = replace_data(TestAudit, item["params"])
print(rep)
params = eval(rep)
expected = eval(item["expected"])
url = conf.get("api", "baseUrl") + item["url"]
headers = eval(conf.get("api", "headers"))
headers["Authorization"] = self.token_result
response = requests.patch(url=url, json=params, headers=headers)
res = response.json()
print("预期结果为{}".format(expected))
print("实际结果为{}".format(res))
try:
self.assertEqual(res["code"], expected["code"])
self.assertEqual(res["msg"], expected["msg"])
# if item["check_sql"]:
# loan_id = jsonpath.jsonpath(res, "$..id")[0]
# sql = db.find_data(item["check_sql"].format(loan_id))
# self.assertTrue(sql)
if item["check_sql"]:
sql = db.find_data(item["check_sql"].format(self.loan_id))[0]
self.assertEqual(2, sql["status"])
except AssertionError as e:
log.error("{}用例执行失败".format(item["title"]))
sh.write_excel(item["case_id"] + 1, 8, "执行不通过")
raise e
else:
log.info("{}用例执行通过".format(item["title"]))
sh.write_excel(item["case_id"] + 1, 8, "执行通过")
def login():
#第二步登录并充值
login_url=conf.get("api","baseUrl")+"/member/login"
login_params={
"mobile_phone":conf.get("testdata","mobile_phone"),
"pwd":conf.get("testdata","pwd")
}
response=requests.post(url=login_url,json=login_params,headers=headers)
if response.json()["code"]==0:
print("登录初始成功")
token=jsonpath.jsonpath(response.json(),"$..token")[0]
member_id=jsonpath.jsonpath(response.json(),"$..id")[0]
#充值500000
recharge_url=conf.get("api","baseUrl")+"/member/recharge"
headers["Authorization"]=token
recharge_params={
"member_id":member_id,
"amount":500000
}
response=requests.post(url=recharge_url,params=recharge_params,headers=headers)
if response.json()["code"]==0:
print("==================充值500000成功==================")
sql = "SELECT * FROM futureloan.member WHERE id={}"
leave_amount = db.find_data(sql.format(member_id))[0]["leave_amount"]
print("用户当前余额为{}".format(leave_amount))
else:
raise ValueError("普通用户初始化充值失败")
else:
raise ValueError("普通账号初始化登录异常")
def random_phone():
phone="131"
while True:
for i in range(8):
ran=random.randint(0,9)
phone+=str(ran)
if not db.find_data("select * from futureloan.member where mobile_phone={}".format(phone)):
return phone
def test_recharge(self, item):
case_id = item["case_id"]
# 第一步：准备数据
url = conf.get("env", "base_url") + item["url"]
# 请求参数
item["data"] = replace_data(item["data"],TestRecharge)
params = eval(item["data"])
# 请求头
headers = eval(conf.get("env", "headers"))
# 请求头中要添加token
headers["Authorization"] = self.token
# 请求方法
method = item["method"]
# 预期结果
expected = eval(item["expected"])
sql = item["check_sql"]
if sql:
s_amount = db.find_data(sql.format(self.member_id))
s_money = s_amount[0]["leave_amount"]
# 第二步：请求接口，获取结果
response = requests.request(url=url, method=method, json=params, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if sql:
e_amount = db.find_data(sql.format(self.member_id))
e_money = e_amount[0]["leave_amount"]
self.assertEqual(float(e_money - s_money), params["amount"])
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
self.excel.write_data(row=case_id +1,column=8,value="失败")
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
self.excel.write_data(row=case_id + 1, column=8, value="通过")
def test_register(self, item):
"""测试注册的测试用例方法"""
# 请求数据
"""参数化开始"""
# 判断请求参数中是否有手机号，需要替换
if "*phone*" in item['data']:
phone = self.random_phone()
# 将参数中的*phone*替换为随机生成的手机号
item['data'] = item['data'].replace('*phone*', phone)
"""参数化结束"""
params = eval(item['data'])
# 请求头
headers = eval(conf.get('env', 'headers'))
# 请求接口
register_url = conf.get('env', 'base_url') + item['url']
# 预期结果
expected = eval(item['expected'])
# 请求方式
method = item['method']
# 实际结果
response = requests.request(method=method,
json=params,
url=register_url,
headers=headers)
res = response.json()
print('预期结果：', expected)
print('请求参数：', params)
print('实际结果：', res)
# 断言判断
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
# 获取测试数据中的 check_sql 判断注册的信息在数据库中是否存在
check_sql = item['check_sql']
if check_sql:
# params['mobile_phone'] 请求参数中的 mobile_phone 的值
res = db.find_data(check_sql.format(params['mobile_phone']))
# 判断res结果是否为空，为空则断言失败，用例执行不通过
self.assertTrue(res)
except AssertionError as e:
log.exception(e)
log.error('用例{},测试未通过'.format(item['title']))
self.excel.write_excel(row=(item['case_id'] + 1),
column=8,
value='未通过')
raise e
else:
log.info('用例{},测试通过'.format(item['title']))
self.excel.write_excel(row=(item['case_id'] + 1),
column=8,
value='通过')
def test_recharge(self, item):
if "#member_id#" in item["params"]:
item["params"] = item["params"].replace("#member_id#",
str(self.member_id))
params = eval(item["params"])
expected = eval(item["expected"])
# if "#member_id#" in item["check_sql"]:
# item["check_sql"]=item["check_sql"].replace("#member_id#",str(self.mobile_id))
url = conf.get("api", "baseUrl") + item["url"]
headers = eval(conf.get("api", "headers"))
headers["Authorization"] = self.token_result
check_sql = item["check_sql"]
if check_sql:
check_sql_before = db.find_data(check_sql.format(self.member_id))
print(check_sql_before, type(check_sql_before),
check_sql_before[0])
leave_amount_before = check_sql_before[0]["leave_amount"]
response = requests.post(url=url, json=params, headers=headers)
res = response.json()
if check_sql:
check_sql_after = db.find_data(check_sql.format(self.member_id))
leave_amount_after = check_sql_after[0]["leave_amount"]
# print(leave_amount_before,leave_amount_after,type(leave_amount_before),type(leave_amount_after))
res2 = {}
res2["code"] = res["code"]
res2["msg"] = res["msg"]
print("预期结果为{}".format(expected))
print("实际结果为{}".format(res2))
try:
self.assertEqual(res2, expected)
if item["check_sql"]:
self.assertEqual(
float(leave_amount_after - leave_amount_before),
float(params["amount"]))
except AssertionError as e:
log.error("{}用例执行失败".format(item["title"]))
sh.write_excel(item["case_id"] + 1, 8, "执行不通过")
raise e
else:
log.info("{}用例执行通过".format(item["title"]))
sh.write_excel(item["case_id"] + 1, 8, "执行通过")
def random_phone():
while True:
phone = "176"
for i in range(0, 8):
i = random.randint(0, 9)
phone += str(i)
sql = "SELECT * FROM futureloan.member WHERE mobile_phone ={}".format(
phone)
res = db.find_data(sql)
if not res:
return phone
def random_phone():
"""随机生成一个未注册手机号"""
while True:
phone = "131"
for i in range(8):
i = random.randint(0, 9)
phone += str(i)
# 判断改手机号是否已注册
sql = "SELECT * FROM futureloan.member WHERE mobile_phone={}".format(phone)
res = db.find_data(sql)
if not res:
return phone
def random_phone():
"""随机生成一个为被注册的手机号码"""
while True:
phone = '131'
for i in range(8):
a = random.randint(0, 9)
phone += str(a)
# 查询数据库中 该手机号是否被注册
res = db.find_data(
'select * from futureloan.member t where t.mobile_phone = {}'.
format(phone))
if not res:
return phone
def random_phone():
# while True:
# mobile_id = random.randint(13000000000, 13099999999)
# sql = db.find_data("select * from member where mobile_phone={}".format(mobile_id))
# if not sql:
# return mobile_id
sql = True
while sql:
mobile_id = random.randint(13000000000, 13099999999)
sql = db.find_data(
"select * from futureloan.member where mobile_phone={}".format(
mobile_id))
if not sql:
return mobile_id
def test_add(self, item):
# 请求接口的url
url = conf.get('env', 'base_url') + item['url']
# 请求参数
params = eval(replace_data(item['data'], TestAddV3))
# 请求参数中添加 timestamp 和sign
crypt_info = HandleSign.generate_sign(self.token_value)
params['timestamp'] = crypt_info['timestamp']
params['sign'] = crypt_info['sign']
# 请求头
# headers = eval(conf.get('env', 'headers'))
# 请求头 V3
headers = eval(conf.get('env', 'headersV3'))
headers['Authorization'] = self.token
# 请求方法
method = item['method']
# 预期结果
expected = eval(item['expected'])
# 请求接口获得请求结果
response = requests.request(method=method,
url=url,
json=params,
headers=headers)
res = response.json()
print('预期结果：', expected)
print('实际结果：', res)
# 断言
try:
self.assertEqual(res['code'], expected['code'])
self.assertEqual(res['code'], expected['code'])
if item['check_sql']:
result = db.find_data(
(item['check_sql']).format(jsonpath(res, '$..id')[0]))
self.assertTrue(result)
except AssertionError as e:
log.error('用例{}，执行失败'.format(item['title']))
log.exception(e)
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='未通过')
raise e
else:
log.info('用例{}，执行成功'.format(item['title']))
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='通过')
def test_withdraw(self, item):
# 第一步：准备数据
case_id = item["case_id"]
# 请求地址
url = conf.get("env", "base_url") + item["url"]
item["data"] = replace_data(item["data"], TestWithdraw)
params = eval(item["data"])
method = item["method"]
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.token
expected = eval(item["expected"])
sql = item["check_sql"]
if sql:
s_amount = db.find_data(sql.format(self.member_id))
s_money = s_amount[0]["leave_amount"]
response = requests.request(url=url,
method=method,
json=params,
headers=headers)
res = response.json()
# 第三步 ：断言
try:
self.assertEqual(res["code"], expected["code"])
self.assertEqual(res["msg"], expected["msg"])
if sql:
e_amount = db.find_data(sql.format(self.member_id))
e_money = s_amount[0]["leave_amount"]
self.assertEqual(float(s_money - e_money), params["amount"])
except AssertionError as e:
log.error("用例执行失败：{}".format(item["title"]))
self.excel.write_data(row=case_id + 1, column=8, value="失败")
raise e
else:
log.info("用例执行通过：{}".format(item["title"]))
self.excel.write_data(row=case_id + 1, column=8, value="通过")
def test_add(self, item):
# 第一步：获取参数
case_id = item["case_id"]
# 请求的url
url = conf.get("env", "base_url") + item["url"]
# 请求的方法
method = item["method"]
# 请求的headers
headers = eval(conf.get("env", "headers"))
if item["interface"] == "add":
headers["Authorization"] = self.token
# 请求的参数
item["data"] = replace_data(item["data"], TestAdd)
params = eval(item["data"])
# 预期的结果
expected = eval(item["expected"])
# 判断执行前的数据库状态
sql = item["check_sql"]
# 第二步 发送请求
response = requests.request(url=url,
method=method,
json=params,
headers=headers)
res = response.json()
if item["interface"] == "login":
# 提取token和用户id保存为类属性
TestAdd.token = "Bearer" + " " + jsonpath(res, "$..token")[0]
TestAdd.member_id = jsonpath(res, "$..id")[0]
print("预期结果：", expected)
print("实际结果：", res)
try:
self.assertEqual(res["code"], expected["code"])
self.assertEqual(res["msg"], expected["msg"])
if item["interface"] == "add":
if sql:
sql = replace_data(sql, TestAdd)
res = db.find_data(sql)
self.assertTrue(res)
except AssertionError as e:
log.error("用例执行失败：{}".format(item["title"]))
log.exception(e)
raise e
self.excel.write_data(row=case_id + 1, column=8, value="失败")
else:
log.info("用例执行通过：{}".format(item["title"]))
self.excel.write_data(row=case_id + 1, column=8, value="通过")
def test_register(self, item):
# 第一步：准备数据
# /member/register
# http://api.lemonban.com/futureloan
url = conf.get("env", "base_url") + item["url"]
headers = eval(conf.get("env", "headers"))
# 判断参数中是否有手机号需要替换
if "*phone*" in item["data"]:
phone = self.random_phone()
# 将参数中的*phone*替换成手机号码
item["data"] = item["data"].replace("*phone*", phone)
params = eval(item["data"])
expected = eval(item["expected"])
method = item["method"]
# 第二步：请求接口，获取实际结果
response = requests.request(url=url, method=method, json=params, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", response.text)
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 用例校验的sql写在excel中如何获取？
sql = item["check_sql"]
if sql:
res = db.find_data(sql.format(params["mobile_phone"]))
# 断言是否能够查询到数据
self.assertTrue(res)
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
def test_audit(self, item):
# 第一步：准备用例数据
url = conf.get("env", "base_url") + item["url"]
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.admin_token
# 替换用例参数
item["data"] = replace_data(item["data"], TestAudit)
params = eval(item["data"])
# 请求方法
method = item["method"]
# 预期结果
expected = eval(item["expected"])
# 第二步：请求接口，获取实际返回的结果
response = requests.request(url=url,
method=method,
json=params,
headers=headers)
res = response.json()
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if item["title"] == "审核通过":
TestAudit.pass_loan_id = params["loan_id"]
# 进行数据库校验
if item["check_sql"]:
sql = item["check_sql"].format(params["loan_id"])
result = db.find_data(sql)[0]
self.assertEqual(expected["status"], result["status"])
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
def test_audit(self,item):
#第一步：请求参数
case_id = item["case_id"]
url = conf.get("env", "base_url") + item["url"]
method = item["method"]
headers = eval(conf.get("env","headers"))
headers["Authorization"] = self.admin_token
print(headers)
item["data"] = replace_data(item["data"],TestAudit)
params = eval(item["data"])
expected = eval(item["expected"])
# 数据库的校验
sql = item["check_sql"]
#第二步：发送请求
response = requests.request(url= url,method=method,json=params,headers=headers)
res = response.json()
print("实际结果",res)
print("预期结果",expected)
#第三步： 断言
try:
self.assertEqual(res["code"], expected["code"])
self.assertEqual(res["msg"], expected["msg"])
if item["title"] == "审核通过":
TestAudit.pass_project_id = params["loan_id"]
if sql:
res = db.find_data(sql.format(self.project_id))
status = res[0]["status"]
self.assertEqual(status,expected["status"])
except AssertionError as e:
log.error("用例执行失败：{}".format(item["title"]))
log.exception(e)
self.excel_audit.write_data(row=case_id + 1, column=8, value="失败")
raise e
else:
log.info("用例执行通过：{}".format(item["title"]))
self.excel_audit.write_data(row=case_id + 1, column=8, value="通过")
def test_invest(self,item):
# 获取用例编号
case_id = item["case_id"]
# 请求接口
url = conf.get("env","base_url") + item["url"]
# 请求方法
method = item["method"]
# 请求头
headers = eval(conf.get("env","headers"))
headers["Authorization"] = self.invest_token
# 请求参数
item["data"] = replace_data(item["data"],TestInvest)
params = eval(item["data"])
# 预期结果
expected = eval(item["expected"])
# 用例执行前的数据校验
if item["check_sql"]:
# 查询投资表记录
sql1 = "SELECT * from futureloan.invest WHERE member_id ={} and loan_id = {}".format(self.invest_member_id,self.loan_id)
# 查询用户的余额
sql2 = "SELECT * from futureloan.member WHERE id = {}".format(self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * from futureloan.financelog WHERE pay_member_id = {}".format(self.invest_member_id)
# 查询用例执行前投资记录的条数
s_invest = len(db.find_data(sql1))
# 查询用例执行前投资用户的余额
s_amount = db.find_data(sql2)[0]["leave_amount"]
# 查询用例执行前流水记录表记录的用户的流水记录条数
s_financelog = len(db.find_data(sql3))
# 第二步 发送请求
response = requests.request(url=url,method=method,json=params,headers=headers)
res = response.json()
print("实际结果",res)
print("预期结果",expected)
# 第三步 断言
try:
self.assertEqual(res["code"],expected["code"])
self.assertEqual(res["msg"],expected["msg"])
if item["check_sql"]:
# 查询投资表记录
sql1 = "SELECT * from futureloan.invest WHERE member_id ={} and loan_id = {}".format(self.invest_member_id, self.loan_id)
# 查询用户的余额
sql2 = "SELECT * from futureloan.member WHERE id = {}".format(self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * from futureloan.financelog WHERE pay_member_id = {}".format(self.invest_member_id)
# 查询用例执行后投资记录的条数
e_invest = len(db.find_data(sql1))
# 查询用例执行后用户的余额
e_amount = db.find_data(sql2)[0]["leave_amount"]
# 查询用例执行后流水记录表记录的用户的流水记录条数
e_financelog = len(db.find_data(sql3))
# 断言比对
self.assertEqual(1,e_invest - s_invest)
self.assertEqual(1,e_financelog - s_financelog)
self.assertEqual(params["amount"],float(s_amount - e_amount))
except AssertionError as e:
log.error("用例执行失败：{}".format(item["title"]))
log.exception(e)
self.excel_audit.write_data(row=case_id + 1, column=8, value="失败")
raise e
else:
log.info("用例执行通过：{}".format(item["title"]))
self.excel.write_data(row=case_id+1,column=8,value="通过")
def test_recharge(self, item):
"""充值接口测试用例方法"""
# 请求头v2(配置文件中获取的为str类型)
# headers = eval(conf.get('env', 'headers'))
# 请求头为v3
headers = eval(conf.get('env', 'headersV3'))
# 将 token 字段添加到请求头中
headers["Authorization"] = self.token
# 请求参数
"""参数化 member_id 开始"""
# if '#member_id#' in item['data']:
# # 将替换 #member_id# self.member_id
# item['data'] = item['data'].replace('#member_id#', str(self.member_id))
# params = eval(item['data'])
params = eval(replace_data(item['data'], TestRechargeV3))
"""参数化 member_id 结束"""
# 获取时间戳和sign值，添加到请求参数中
cryto_info = HandleSign.generate_sign(self.token_value)
params['timestamp'] = cryto_info['timestamp']
params['sign'] = cryto_info['sign']
# 请求方法
method = item['method']
# 请求接口
recharge_url = conf.get('env', 'base_url') + item['url']
# 预期结果
expected = eval(item['expected'])
# 获取充值前数据库中的金额
sql = item['check_sql']
if sql:
start_amount = db.find_data(sql.format(
self.member_id))[0]['leave_amount']
# 实际结果
response = requests.request(method=method,
url=recharge_url,
json=params,
headers=headers)
res = response.json()
print('预期结果：', expected)
print('实际结果：', res)
try:
# 将充值前后的金额之差，与充值的金额比较，相等则通过，不等则失败
if sql:
# 获取充值后数据库中的金额
end_amount = db.find_data(sql.format(
self.member_id))[0]['leave_amount']
# 断言前后数据库中数值的变化和实际传入参数的大小是否一致
self.assertEqual(float(end_amount - start_amount),
eval(item['data'])['amount'])
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
self.excel.write_excel(row=(item['case_id'] + 1),
column=8,
value='未通过')
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
self.excel.write_excel(row=(item['case_id'] + 1),
column=8,
value='通过')
def test_withdraw(self, item):
"""测试提现接口的方法"""
# 请求接口
url = conf.get('env', 'base_url') + item['url']
# 请求参数
# if '#member_id#' in item['data']:
# item['data'] = item['data'].replace('#member_id#', str(self.member_id))
# params = eval(item['data'])
params = eval(replace_data(item['data'], TestWithdrawV3))
# 请求参数中添加 timestamp 和 sign
crypt_info = HandleSign.generate_sign(self.token_value)
params['timestamp'] = crypt_info['timestamp']
params['sign'] = crypt_info['sign']
# 请求头v2
# headers = eval(conf.get('env', 'headers'))
# 请求头v3
headers = eval(conf.get('env', 'headersV3'))
headers['Authorization'] = self.token
method = item['method']
# 获取数据库中的提现之前的余额
sql = item['check_sql']
if sql:
s_amount = db.find_data(sql.format(
self.member_id))[0]['leave_amount']
# 预期结果
expected = eval(item['expected'])
# 请求参数获得实际结果
response = requests.request(method=method,
url=url,
headers=headers,
json=params)
res = response.json()
print('预期结果：', expected)
print('实际结果：', res)
# 断言结果
try:
if sql:
e_amount = db.find_data(sql.format(
self.member_id))[0]['leave_amount']
self.assertTrue(float(s_amount - e_amount),
jsonpath(res, '$..leave_amount')[0])
self.assertEqual(jsonpath(res, '$.code')[0], expected['code'])
self.assertEqual(jsonpath(res, '$.msg')[0], expected['msg'])
except AssertionError as e:
log.error('用例{}：执行失败'.format(item['title']))
log.exception(e)
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='未通过')
raise e
else:
log.info('用例{}：执行通过'.format(item['title']))
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='通过')
def test_invest(self, item):
# 请求数据准备
url = conf.get('env', 'base_url') + item['url']
# 请求头 v2
# headers = eval(conf.get('env', 'headers'))
# 请求头v3
headers = eval(conf.get('env', 'headersV3'))
headers['Authorization'] = self.invest_token
params = eval(replace_data(item['data'], TestInvestV3))
# 请求参数添加timestamp和sign
crypt_info = HandleSign.generate_sign(self.invest_token_value)
params['timestamp'] = crypt_info['timestamp']
params['sign'] = crypt_info['sign']
method = item['method']
# 预计结果
expected = eval(item['expected'])
# 数据库判断逻辑（请求接口之前）
if item['check_sql']:
# 查询投资表记录
sql1 = "SELECT * FROM futureloan.invest WHERE member_id={} and loan_id={}".format(
self.invest_member_id, self.loan_id)
# 查询用户余额
sql2 = "SELECT leave_amount FROM futureloan.member where id={}".format(
self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id={}".format(
self.invest_member_id)
# 用例执行之前投资记录的条数
s_invest = len(db.find_data(sql1))
# 用例执行之前投资用户的余额
s_amount = db.find_data(sql2)[0]['leave_amount']
# 用例执行之前流水记录表用户的流水记录条数
s_financelog = len(db.find_data(sql3))
# 实际结果
response = requests.request(method=method,
url=url,
json=params,
headers=headers)
res = response.json()
print('请求参数', params)
print('预期结果：', expected)
print('实际结果：', res)
# 断言
try:
self.assertEqual(res['code'], expected['code'])
self.assertEqual(res['code'], expected['code'])
# 数据库判断逻辑（请求接口之后）
if item['check_sql']:
# 查询投资表记录
sql1 = "SELECT * FROM futureloan.invest WHERE member_id={} and loan_id={}".format(
self.invest_member_id, self.loan_id)
# 查询用户余额
sql2 = "SELECT leave_amount FROM futureloan.member where id={}".format(
self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id={}".format(
self.invest_member_id)
# 用例执行之后投资记录的条数
e_invest = len(db.find_data(sql1))
# 用例执行之后投资用户的余额
e_amount = db.find_data(sql2)[0]["leave_amount"]
# 用例执行之后流水记录表用户的的流水记录条数
e_financelog = len(db.find_data(sql3))
# 断言判断
# 1、对比执行前后投资表记录数量是否+1
self.assertEqual(1, e_invest - s_invest)
# 2、对比用户余额
self.assertEqual(params['amount'], s_amount - e_amount)
# 3、对比执行前后流水记录表记录数量是否+1
self.assertEqual(1, e_financelog - s_financelog)
except AssertionError as e:
log.error('用例{}，执行失败'.format(item['title']))
log.exception(e)
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='未通过')
raise e
else:
log.info('用例{}，执行成功'.format(item['title']))
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='通过')
def init_env_data():
#第一步，普通账号注册账户
register_url = conf.get("api", "baseUrl") + "/member/register"
headers = eval(conf.get("api", "headers"))
params = {"mobile_phone": random_phone(), "pwd": 111111111, "type": 1}
response = requests.post(url=register_url, json=params, headers=headers)
res = response.json()
if res["code"] == 0:
print("==============初始化注册成功===============")
conf.write_data(section="testdata",
option="mobile_phone",
value=params["mobile_phone"])
conf.write_data(section="testdata",
option="pwd",
value=str(params["pwd"]))
#第二步登录并充值
login_url = conf.get("api", "baseUrl") + "/member/login"
login_params = {
"mobile_phone": conf.get("testdata", "mobile_phone"),
"pwd": conf.get("testdata", "pwd")
}
response = requests.post(url=login_url,
json=login_params,
headers=headers)
if response.json()["code"] == 0:
print("登录初始成功")
token = "Bearer" + " " + jsonpath.jsonpath(response.json(),
"$..token")[0]
member_id = jsonpath.jsonpath(response.json(), "$..id")[0]
#充值500000
recharge_url = conf.get("api", "baseUrl") + "/member/recharge"
headers["Authorization"] = token
recharge_params = {"member_id": member_id, "amount": 500000}
response = requests.post(url=recharge_url,
json=recharge_params,
headers=headers)
print(response.json())
if response.json()["code"] == 0:
print("==================充值500000成功==================")
sql = "SELECT * FROM futureloan.member WHERE id={}"
leave_amount = db.find_data(
sql.format(member_id))[0]["leave_amount"]
print("用户当前余额为{}".format(leave_amount))
else:
raise ValueError("普通用户初始化充值失败")
else:
raise ValueError("普通账号初始化登录异常")
else:
raise ValueError("普通账号初始化注册异常")
#管理员账号注册账户
register_url = conf.get("api", "baseUrl") + "/member/register"
headers = eval(conf.get("api", "headers"))
admin_params = {
"mobile_phone": random_phone(),
"pwd": 111111111,
"type": 0
}
response = requests.post(url=register_url,
json=admin_params,
headers=headers)
res = response.json()
if res["code"] == 0:
print("==============初始化管理员账号注册成功===============")
conf.write_data(section="testdata",
option="admin_mobile",
value=admin_params["mobile_phone"])
conf.write_data(section="testdata",
option="admin_pwd",
value=str(params["pwd"]))
else:
raise ValueError("管理员账号初始化注册异常")
#投资账号注册账户
register_url = conf.get("api", "baseUrl") + "/member/register"
headers = eval(conf.get("api", "headers"))
params = {"mobile_phone": random_phone(), "pwd": 111111111, "type": 0}
response = requests.post(url=register_url, json=params, headers=headers)
res = response.json()
if res["code"] == 0:
print("==============初始化投资账户注册成功===============")
conf.write_data(section="testdata",
option="invest_mobile",
value=params["mobile_phone"])
conf.write_data(section="testdata",
option="invest_pwd",
value=str(params["pwd"]))
#第二步登录并充值
login_url = conf.get("api", "baseUrl") + "/member/login"
login_params = {
"mobile_phone": conf.get("testdata", "invest_mobile"),
"pwd": conf.get("testdata", "pwd")
}
response = requests.post(url=login_url,
json=login_params,
headers=headers)
if response.json()["code"] == 0:
print("登录初始成功")
token = "Bearer" + " " + jsonpath.jsonpath(response.json(),
"$..token")[0]
member_id = jsonpath.jsonpath(response.json(), "$..id")[0]
#充值500000
recharge_url = conf.get("api", "baseUrl") + "/member/recharge"
headers["Authorization"] = token
recharge_params = {"member_id": member_id, "amount": 500000}
response = requests.post(url=recharge_url,
json=recharge_params,
headers=headers)
print(response.json())
if response.json()["code"] == 0:
print("==================投资账户充值500000成功==================")
sql = "SELECT * FROM futureloan.member WHERE id={}"
leave_amount = db.find_data(
sql.format(member_id))[0]["leave_amount"]
print("用户当前余额为{}".format(leave_amount))
else:
raise ValueError("投资用户初始化充值失败")
else:
raise ValueError("投资账号初始化登录异常")
else:
raise ValueError("投资账号初始化注册异常")
def test_invest(self, item):
"""执行投资的用例"""
# 第一步：准备用例数据
url = conf.get("env", "base_url") + item["url"]
params = eval(replace_data(item["data"], TestInvest))
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.invest_token
method = item["method"]
expected = eval(item["expected"])
# 用例执行之前查询sql
if item["check_sql"]:
# 查询投资表记录
sql1 = "SELECT * FROM futureloan.invest WHERE member_id={} and loan_id={}".format(
self.invest_member_id, self.loan_id)
# 查询用户余额
sql2 = "SELECT leave_amount FROM futureloan.member where id={}".format(
self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id={}".format(
self.invest_member_id)
# 查询
# 用例执行之前投资记录的条数
s_invest = len(db.find_data(sql1))
# 用例执行之前投资用户的余额
s_amount = db.find_data(sql2)[0]["leave_amount"]
# 用例执行之前流水记录表用户的的流水记录条数
s_financelog = len(db.find_data(sql3))
# 第二步：请求接口，获取实际结果
response = requests.request(url=url,
method=method,
headers=headers,
json=params)
res = response.json()
print("预期结果：", expected)
print("实际结果：", response.text)
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 用例执行之前查询sql
if item["check_sql"]:
# 查询投资表记录
sql1 = "SELECT * FROM futureloan.invest WHERE member_id={} and loan_id={}".format(
self.invest_member_id, self.loan_id)
# 查询用户余额
sql2 = "SELECT leave_amount FROM futureloan.member where id={}".format(
self.invest_member_id)
# 查询流水记录
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id={}".format(
self.invest_member_id)
# 查询
# 用例执行之后投资记录的条数
e_invest = len(db.find_data(sql1))
# 用例执行之后投资用户的余额
e_amount = db.find_data(sql2)[0]["leave_amount"]
# 用例执行之后流水记录表用户的的流水记录条数
e_financelog = len(db.find_data(sql3))
# 断言比对
# 1、比对执行前后投资表记录数量是否+1
self.assertEqual(1, e_invest - s_invest)
# 2、对比用户余额
self.assertEqual(params["amount"], s_amount - e_amount)
# 3、比对执行前后流水记录表记录数量是否+1
self.assertEqual(1, e_financelog - s_financelog)
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
