def test_audit(self, item):
url = os.path.join(handle_conf.Conf.get("env", "url")) + item["url"]
headers = eval(handle_conf.Conf.get("env", "headers"))
headers["Authorization"] = self.admin_token
method = item["method"]
item["data"] = handle_data.replace_data(item['data'], Test_Aduit)
params = eval(item["data"])
expected = eval(item["expected"])
case_id = item["case_id"] + 1
response = requests.request(method=method,
url=url,
headers=headers,
json=params)
res = response.json()
print("预期结果：{}0".format(expected))
print("实际结果：{}".format(res))
try:
self.assertEqual(res["code"], expected["code"])
self.assertEqual(res["msg"], expected["msg"])
if item["check_sql"]:
status = handle_db.database_info.find_data(
item["check_sql"].format(params["loan_id"]))[0]
self.assertEqual(expected["status"], status["status"])
except AssertionError as e:
handle_logs.log.error("未通过，记录信息为{}".format(item["title"]))
handle_logs.log.exception(e)
self.case_file.write_case(row=case_id, coulmn=8, value="失败")
raise e
else:
handle_logs.log.info("通过，记录信息为{}".format(item["title"]))
self.case_file.write_case(row=case_id, coulmn=8, value="成功")
def test_login(self, item):
#准备用例数据
params = eval(replace_data(item['data'], longin))
print(params)
# params = eval(item["data"])
url = conf.get('url', 'url') + item['url']
method = item['method']
title = item['title']
expected = item['expected']
response = requests.request(method=method, url=url, json=params)
res = response.json()
print('实际结果：{}'.format(res))
print('预期结果：{}'.format(expected))
try:
self.assertEqual(str(expected), jsonpath(res, '$.statusCode')[0])
except AssertionError as e:
log.error('{}用例执行失败'.format(item['title']))
self.excel.write_data(row=item['case_id'] + 1,
column=7,
value='失败')
raise e
else:
log.error('{}用例执行成功'.format(item['title']))
self.excel.write_data(row=item['case_id'] + 1,
column=7,
value='成功')
try:
if 'token' in res['data']:
longin.token = jsonpath(res, '$..token')[0]
except:
pass
def test_info(self, item):
# 请求接口
url = conf.get('env', 'base_url') + replace_data(item['url'], TestInfo)
# 请求方法
method = item['method']
# 请求头
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = self.token
# 预期结果
expected = eval(item['expected'])
# 请求接口获得实际结果
response = requests.request(method=method, url=url, headers=headers)
res = response.json()
print('预计结果：', expected)
print('实际结果：', res)
# 断言
try:
self.assertEqual(res['code'], expected['code'])
self.assertEqual(res['code'], expected['code'])
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_login(self, item):
# 第一步：准备用例数据
# 接口地址
url = conf.get("env", "base_url") + item["url"]
# 请求头
headers = eval(conf.get("env", "headers"))
# 请求参数
item["data"] = replace_data(item["data"], TestLogin)
params = eval(item["data"])
# 预取结果
expected = eval(item["expected"])
# 请求方法
method = item["method"]
# 第二步：调用接口，获取实际结果
response = requests.request(method,
url=url,
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"])
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
def test_add(self, item):
url = handle_conf.Conf.get("env", "url") + item["url"]
headers = eval(handle_conf.Conf.get("env" , "headers"))
headers["Authorization"] = self.token
case_id = item["case_id"] + 1
item["data"] = handle_data.replace_data(item["data"], Add)
params = eval(item["data"])
expected = eval(item['expected'])
method = item["method"]
response = requests.request(method=method, token=self.token, headers=headers, url=url, json=params)
res = response.json()
print("预期结果：{}0".format(expected))
print("实际结果：{}".format(res))
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected['msg'], res['msg'])
if item["check_sql"]:
info = handle_db.database_info.find_data(item["check_sql"].format(self.uesr_id))
self.assertTrue(info)
except AssertionError as e:
handle_logs.log.error("失败，记录信息{}".format(item["title"]))
handle_logs.log.exception(e)
self.file_name.write_case(row=case_id, coulmn=8, value="失败")
raise e
else:
handle_logs.log.info("成功，记录信息为{}".format(item["title"]))
self.file_name.write_case(row=case_id, coulmn=8, value="成功")
def test_login(self, item):
case_id = item["case_id"] + 1
method = item["method"]
url = handle_conf.Conf.get("env", "url") + item["url"]
item["data"] = handle_data.replace_data(item["data"], TestLogin)
params = eval(item["data"])
expected = eval(item["expected"])
headers = eval(handle_conf.Conf.get("env", "headers"))
response = requests.request(method=method,
url=url,
json=params,
headers=headers)
res = response.json()
print("预期结果：{}".format(expected))
print("实际结果：{}".format(res))
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
handle_logs.log.error("用例{}未通过".format(item["title"]))
handle_logs.log.exception(e)
self.file_name.write_case(row=case_id, coulmn=8, value="失败")
raise e
else:
handle_logs.log.info("用例{}通过".format(item["title"]))
self.file_name.write_case(row=case_id, coulmn=8, value="成功")
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"]
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_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_invest(self, item):
url = handle_conf.Conf.get("env", "url") + item["url"]
headers = eval(handle_conf.Conf.get('env', 'headers'))
headers["Authorization"] = self.invest_token
item["data"] = handle_data.replace_data(item["data"], Test_Invest)
params = eval(item["data"])
method = item['method']
expected = eval(item["expected"])
case_id = item["case_id "] + 1
if item["check_sql"]:
"""查询原始表该投资用户在表内的投资记录"""
sql1 = "SELECT * FROM futureloan.invest WHERE member_id ={} and loan_id ={}".format(
self.invest_id, self.loan_id)
"""余额"""
sql2 = "SELECT * FROM futureloan.member WHERE member_id ={}".format(
self.invest_id)
"""流水记录"""
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id = {}".format(
self.invest_id)
f_invest = len(handle_db.database_info.find_data(sql1))
f_amount = handle_db.database_info.find_data(sql2)[0]["amount"]
f_financelog = len(handle_db.database_info.find_data(sql3))
response = requests.request(method=method,
url=url,
headers=headers,
json=params)
res = response.json()
print("预期结果：{}0".format(expected))
print("实际结果：{}".format(res))
try:
self.assertEqual(expected['code'], res["code"])
self.assertEqual(expected['msg'], res['msg'])
if item["check_sql"]:
sql1 = "SELECT * FROM futureloan.invest WHERE member_id ={} and loan_id ={}".format(
self.invest_id, self.loan_id)
sql2 = "SELECT * FROM futureloan.member WHERE member_id ={}".format(
self.invest_id)
sql3 = "SELECT * FROM futureloan.financelog WHERE pay_member_id = {}".format(
self.invest_id)
s_invest = len(handle_db.database_info.find_data(sql1))
s_amount = handle_db.database_info.find_data(sql2)[0]["amount"]
s_financelog = len(handle_db.database_info.find_data(sql3))
self.assertEqual(s_invest - f_invest, 1)
self.assertEqual(s_amount - f_amount, params["amount"])
self.assertEqual(s_financelog - f_financelog, 1)
except AssertionError as e:
handle_logs.log.error("失败，记录信息为{}".format(item['title']))
handle_logs.log.exception(e)
self.case_file.write_case(row=case_id, coulmn=8, value="失败")
else:
handle_logs.log.info("成功，记录信息为{}".format(item['title']))
self.case_file.write_case(row=case_id, coulmn=8, value="成功")
def test_newpay(self, item):
"""设置交易密码"""
# 准备用例数据
url = conf.get('url', 'url') + item['url']
# 准备数据
params = eval(replace_data(item['data'], test_newpaypd))
print(params)
# 获取请求方式
method = item['method']
# 获取实际结果
response = requests.request(method=method, url=url, json=params)
res = response.json()
print('实际结果：{}'.format(res))
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_audit(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.admin_token
# 替换用例参数
item["data"] = replace_data(item["data"], TestAuditV3)
params = eval(item["data"])
# 请求参数添加timestamp和sign
crypt_info = HandleSign.generate_sign(self.admin_token_value)
params['timestamp'] = crypt_info['timestamp']
params['sign'] = crypt_info['sign']
# 请求方法
method = item["method"]
# 预期结果
expected = eval(item["expected"])
# 第二步：请求接口，获取实际返回的结果
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 item["title"] == "审核通过":
TestAuditV3.pass_loan_id = params["loan_id"]
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_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_testcases(self, item):
# 1. 准备测试数据
url = conf.get("env", "base_url") + item["url"]
method = item["method"]
# 替换name
if "#name#" in item["data"]:
item["data"] = item["data"].replace("#name#",username())
item["data"] = replace_data(item["data"],TestTestcases)
params = eval(item["data"])
headers = {"Authorization": "JWT" + " " + self.token}
expected = eval(item["expected"])
# 2. 请求接口，获取实际结果
res = requests.request(method, url, json=params, headers=headers).json()
# 接口请求后，pass_name设置为类属性
if item["title"] == "正常创建用例":
TestTestcases.pass_name = params["name"]
# 替换掉expect里面的name
expected["name"] = TestTestcases.pass_name
print("-------当前执行的用例是:{}----------".format(item["title"]))
print("请求参数：", params)
print("预期结果：", expected)
print("实际结果：", res)
print("===============执行结束===============\n")
# 3. 断言
try:
assert_dict_item(expected, res)
except AssertionError as e:
log.exception(e)
log.error("--测试用例：{}--执行失败".format(item["title"]))
raise e
else:
log.info("--测试用例：{}--执行通过".format(item["title"]))
def test_recharge(self, item):
url = handle_conf.Conf.get("env", "url") + item["url"]
method = item['method']
headers = eval(handle_conf.Conf.get("env", "headers"))
headers["Authorization"] = self.token
item["data"] = handle_data.replace_data(item["data"], Test_Recharge)
params = eval(item["data"])
expected = eval(item["expected"])
case_id = item["case_id"] + 1
if item["check_sql"]:
old_amount = handle_db.database_info.find_data(
item["check_sql"].format(self.user_id))
old_money = old_amount[0]["leave_amount"]
response = requests.request(method=method,
url=url,
json=params,
headers=headers,
token=self.token)
res = response.json()
print("预期结果：{}0".format(expected))
print("实际结果：{}".format(res))
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res['msg'])
if item["check_sql"]:
new_amount = handle_db.database_info.find_data(
item["check_sql"].format(self.user_id))
new_money = new_amount[0]["leave_amount"]
self.assertEqual(float(new_money - old_money),
params["amount"])
except AssertionError as e:
handle_logs.log.error("失败，信息为{}".format(item['title']))
handle_logs.log.exception(e)
self.file_name.write_case(row=case_id, coulmn=8, value="失败")
raise e
else:
handle_logs.log.info("成功，信息为{}".format(item["title"]))
self.file_name.write_case(row=case_id, coulmn=8, value="成功")
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_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_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_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_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_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"]))
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"]))
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_invest(self, case):
'''投资用例'''
headers = eval(conf.get('env', 'headers'))
# 如果不是登陆请求，则添加一个token
if case['interface'] != 'login':
headers['Authorization'] = getattr(EnvData, 'token')
url = conf.get('env', 'BASE_URL') + case['url']
method = case['method']
# case['data']=replace_data(case['data'])
# print(case['data'])
data = eval(replace_data(case['data']))
expected = eval(case['expected'])
row = case['case_id'] + 1
if case['check_sql']:
sql1 = 'select * from futureloan.invest where member_id= #member_id#;'
start_invest_count = self.db.count(replace_data(sql1))
sql2 = 'select leave_amount from futureloan.member where id= #member_id#;'
start_leave_amount = self.db.find_one(
replace_data(sql2))['leave_amount']
sql3 = 'select * from futureloan.financelog where pay_member_id= #member_id#;'
start_financelog_count = self.db.count(replace_data(sql3))
response = request(method=method, json=data, url=url, headers=headers)
res = response.json()
# 如果是登陆接口，则提取用户Id+token
if case['interface'] == 'login':
member_id = str(jsonpath(res, '$..id')[0])
token = 'Bearer ' + jsonpath(res, '$..token')[0]
setattr(EnvData, 'member_id', member_id)
setattr(EnvData, 'token', token)
# 如果是加标接口，则提取标Id
if case['interface'] == 'add':
loan_id = str(jsonpath(res, '$..id')[0])
setattr(EnvData, 'loan_id', loan_id)
print(getattr(EnvData, 'loan_id'))
if case['check_sql']:
sql1 = 'select * from futureloan.invest where member_id= #member_id#;'
end_invest_count = self.db.count(replace_data(sql1))
sql2 = 'select leave_amount from futureloan.member where id= #member_id#;'
end_leave_amount = self.db.find_one(
replace_data(sql2))['leave_amount']
sql3 = 'select * from futureloan.financelog where pay_member_id= #member_id#;'
end_financelog_count = self.db.count(replace_data(sql3))
try:
self.assertEqual(res['code'], expected['code'])
self.assertEqual(res['msg'], expected['msg'])
# 判断是否需要进行sql校验
if case['check_sql']:
self.assertEquals(1, end_invest_count - start_invest_count)
self.assertEquals(Decimal(str(data['amount'])),
start_leave_amount - end_leave_amount)
self.assertEquals(
1, end_financelog_count - start_financelog_count)
if case['title'] == '满标':
sql4 = 'select id from futureloan.invest where loan_id =#loan_id#;'
invest_ids = self.db.find_all(replace_data(sql4))
# setattr(EnvData,'invest_ids',invest_ids)
for invest_id in invest_ids:
sql5 = 'select * from futureloan.repayment where invest_id={}'.format(
invest_id['id'])
count = self.db.count(sql5)
# 只要数据条数不为0即可校验通过
self.assertTrue(count)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value='fail')
log.error('用例--{}--执行未通过'.format(case['title']))
log.exception(e)
log.debug('预期结果:{}'.format(expected))
log.debug('实际结果:{}'.format(res))
raise e
else:
self.excel.write_data(row=row, column=8, value='pass')
log.info('用例--{}--执行通过'.format(case['title']))
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"]))
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 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="通过")
