def test_getChatVedio(self, case):
se = Session()
# 准备用例数据
login_url = "http://doctor.yy365.cn/index/login"
login_data = {
"username": conf.get("test_data", "shop_user"),
"password": conf.get("test_data", "shop_pwd")}
response = se.post(url=login_url, data=login_data)
url1 = conf.get("env", "url") + case["url"]
data1 = eval(case["data"])
response2 = se.post(url=url1, data=data1, verify=False)
res = response2.json()
row = case["case_id"] + 1
expected = eval(case["expected"])
try:
self.assertEqual(expected["CODE"], res["CODE"])
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_getPasteList(self, case):
# 准备用例数据
url = "https://doctor.yy365.cn/ComHandle/getPasteList"
method = "post"
headers = {"Content-Type": "application/x-www-form-urlencoded"}
data = {"QueryType": "", "Params": '{"search":""}',
"UserGuid": "MTg2OTkwfEA5Yzg0MWM4ZThmNzdjY2FhYjAwZTg2MDY2MmZmNDNjM3xAN2E2ZmQ0ZmRkOWRjYTRlZGQ4NzRiNmUzNjEzNmExOGU-"}
res = request(url=url, method=method, data=data, headers=headers, verify=False)
row = case["case_id"] + 1
expected = eval(case["expected"])
# 调用接口,获取实际结果
try:
self.assertEqual(expected["status_code"], res.status_code)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_find_userinfo(self, case):
# 1、准备请求参数
# 替换url中的会员id
url = conf.get("env", "base_url") + replace_data(case["url"])
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
method = case["method"]
expected = eval(case["expected"])
row = case["case_id"] + 1
# 2、发起请求，获取实际结果
response = request(url=url, method=method, headers=headers)
res = response.json()
print("预期结果：{}".format(expected))
print("实际结果：{}".format(res))
# 3、断言
try:
# 断言预期结果与实际结果是否一致
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
# 将结果写入日志文件和excel中
log.error("测试用例--{}--未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
result = "未通过"
raise e
else:
log.info("测试用例--{}--通过".format(case["title"]))
result = "通过"
finally:
self.excel.write_data(row=row, column=8, value=result)
def test_loans(self,cas):
url = conf.get('env','url') + cas['url']
data = eval(cas['data'])
headers = eval(conf.get('env','headers'))
method = cas['method']
expected = eval(cas['expected'])
row = cas['case_id'] + 1
respones = request(url=url,method=method,params=data,headers=headers)
res = respones.json()
try:
self.assertEqual(expected['code'],res['code'])
self.assertEqual(expected['msg'],res['msg'])
#判断返回的数据条数
self.assertEqual(expected['len'],len(res['data']))
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.execl.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.execl.write(row=row, column=8, value='通过')
def test_login(self, cas):
url = cas['url']
method = cas['method']
headers = eval(conf.get('env', 'headers'))
data = eval(cas['data'])
expected = eval(cas['expected'])
row = cas['case_id'] + 1
respons = request(url=url, method=method, json=data, headers=headers)
res = respons.json()
print('实际结果：', res)
print('预期结果：', expected)
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
except AssertionError as e:
log.error('用例{}没有通过，错误等级为error'.format(cas['title']))
log.debug('预期结果{}'.format(cas['expected']))
log.debug('实际结果{}'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='未通过')
raise e
else:
log.info('用例{}执行通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_pwd(self, case):
# 准备用例数据
method, headers, url, data, row, expected = getdata(case)
# 调用接口,获取实际结果
res = (request(url=url,
method=method,
data=data,
headers=headers,
verify=False)).json()
try:
result = ''
if 'result' in res:
result = res['result']
elif 'ERROR' in res:
result = res['ERROR']
self.assertEqual(expected, result)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_loans(self, cas):
cas['url'] = replace_data(cas['url'])
url = conf.get('env', 'url') + cas['url']
headers = eval(conf.get('env', 'headers'))
headers["Authorization"] = getattr(EnvData, "token")
method = cas['method']
expected = eval(cas['expected'])
row = cas['case_id'] + 1
respones = request(url=url, method=method, headers=headers)
res = respones.json()
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.execl.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.execl.write(row=row, column=8, value='通过')
def test_withdraw(self, case):
# 1、准备用例数据
url = conf.get("env", "base_url") + case["url"]
method = case["method"]
# 准备用例参数
# 替换参数中的用户id
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 准备请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 判断用例是否需要数据库校验，获取提现之前的账户余额
if case["check_sql"]:
sql = replace_data(case["check_sql"])
start_money = self.db.find_one_data(sql)["leave_amount"]
print("提现前得余额：", start_money)
# 2、发送请求获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果:", res)
# 判断用例是否需要数据库校验，获取提现之后的账户余额
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_money = self.db.find_one_data(sql)["leave_amount"]
print("提现后得余额：", end_money)
# 3、断言预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 判断是否需要进行sql校验
if case["check_sql"]:
# 将提现金额转换为decimal类型（因为数据库中的金额是decimal类型的）
recharge_money = decimal.Decimal(str(data["amount"]))
self.assertEqual(recharge_money, start_money - end_money)
except AssertionError as e:
# 将结果写入日志中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
result = "未通过"
raise e
else:
# 结果写到日志
log.info("用例--{}--执行通过".format(case["title"]))
result = "通过"
finally:
# 将结果写入到excel中
self.excel.write_data(row=row, column=8, value=result)
def test_register(self, case):
"""
case={"address": "https://www.aliexpress.com/store/3213085", "asstext": "店铺验证成功"}
:param case:
:return:
"""
# 1、准备用例数据
# 请求方法
method = case["method"]
# 请求地址
url = case["url"]
# 请求参数
# 判断是否有手机号码需要替换
if "#phone#" in case["data"]:
# 随机生成一个手机号码
phone = self.random_phone()
# 将参数中的#phone#替换成随机生成的手机号码
case["data"] = case["data"].replace("#phone#", phone)
data = eval(case["data"])
# 请求头
headers = eval(conf.get("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 用例所在行
row = case["case_id"] + 1
# 2、发送请求获取实际结果
response = request(method=method, url=url, json=data, headers=headers)
# 获取实际结果
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 3、断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 判断是否需要进行sql校验
if case["check_sql"]:
sql = case["check_sql"].replace("#phone#",
data["mobile_phone"])
res = self.db.find_data_count(sql)
self.assertEqual(1, res)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_withdraw(self, case):
# 第一步：准备用例数据
# 请求方法
method = case["method"]
# 请求地址
url = conf.get("env", "BASE_URL") + case["url"]
# 请求参数，替换用例中#member_id#
data = eval(case["data"].replace("#member_id#", self.member_id))
# 请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.token
# 期望结果
expected = eval(case["expected"])
# 数据库前置查询
if case["check_sql"]:
sql = case["check_sql"].format(self.member_id)
start_money = self.db.find_one(sql)["leave_amount"]
# 需要回写的行
row = case["case_id"] + 1
# 第二步：接口调用
response = requests.request(method=method,
url=url,
json=data,
headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 数据库后置查询
if case["check_sql"]:
sql = case["check_sql"].format(self.member_id)
end_money = self.db.find_one(sql)["leave_amount"]
# 第三步：数据断言和数据库断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 数据库断言
if case["check_sql"]:
recharge_money = decimal.Decimal(str(data["amount"]))
self.assertEqual(recharge_money, start_money - end_money)
except AssertionError as e:
# 结果回写到excel中
log.error("用例{}执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_excel(row=row, column=8, value="未通过")
raise e
else:
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_excel(row=row, column=8, value="通过")
def test_withdraw(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
# 准备用例参数
# 替换参数中的用户id,
case["data"] = case["data"].replace("#member_id#", self.member_id)
data = eval(case["data"])
# 准备请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.token
expected = eval(case["expected"])
row = case["case_id"] + 1
# 判断该用例是否需要数据库校验，获取取现之前的账户余额
if case["check_sql"]:
sql = case["check_sql"].format(self.member_id)
start_money = self.db.find_one(sql)["leave_amount"]
print("取现之前的金额：", start_money)
# 第二步： 发送请求获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 判断该用例是否需要数据库校验，获取取现之后的账户余额
if case["check_sql"]:
sql = case["check_sql"].format(self.member_id)
end_money = self.db.find_one(sql)["leave_amount"]
print("取现之后的金额：", end_money)
# 第三步：断言预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 判断是否需要进行sql校验
if case["check_sql"]:
# 将取现金额转换为decimal类型（因为数据库中的金额是decimal类型的）
recharge_money = decimal.Decimal(str(data["amount"]))
self.assertEqual(recharge_money, start_money - end_money)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_add(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
# 替换参数中的用户id,
# case["data"] = case["data"].replace("#member_id#", self.member_id)
# --------替换用例中的动态数据
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 准备请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 加标之前，查询数据库中该用户标的数量
if case["check_sql"]:
# sql = case["check_sql"].replace("#member_id#",self.member_id)
sql = replace_data(case["check_sql"])
start_count = self.db.find_count(sql)
# 第二步： 发送请求获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 第三步：断言预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if case["check_sql"]:
# 加标之后
# sql = case["check_sql"].replace("#member_id#", self.member_id)
replace_data(case["check_sql"])
end_count = self.db.find_count(sql)
self.assertEqual(1, end_count - start_count)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_audit(self, case):
# 1、准备用例数据
url = conf.get("env", "base_url") + case["url"]
method = case["method"]
# 准备用例参数
# 替换参数中的用户id
# 判读是否需要要替换审核通过的标id
if "#pass_loan_id#" in case["data"]:
# 将之前保存的审核通过的id，替换到该用例中
case["data"] = case["data"].replace("#pass_loan_id#",
self.pass_loan_id)
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 准备请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "admin_token")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 2、发送请求获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果:", res)
# 判断是否是审核通的用例，并且审核成功
if case["title"] == "审核通过" and res["msg"] == "OK":
# 将执行通过的标id保存为类属性
TestAudit.pass_loan_id = str(data["loan_id"])
# 3、断言预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
# 将结果写入日志中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
result = "未通过"
raise e
else:
# 结果写到日志
log.info("用例--{}--执行通过".format(case["title"]))
result = "通过"
finally:
# 将结果写入到excel中
self.excel.write_data(row=row, column=8, value=result)
def test_audit(self, case):
# 第一步：准备数据
url = conf.get("env", "url") + case["url"]
# >>>>>>>>>>>判断是否需要替换审核通过的标id >>>>>>>>>>>
if "#pass_loan_id#" in case["data"]:
# >>>>>>>>>>> 将之前保存的审核通过的标ID 类属性的地方，替换到该用例中 >>>>>>>>>>>
case["data"] = case["data"].replace("#pass_loan_id#",
str(self.pass_loan_id))
data = eval(case["data"].replace("#loan_id#", str(self.loan_id)))
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.admin_token
if case["title"] == "普通用户进行审核":
headers["Authorization"] = self.user_token
method = case["method"]
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：调用接口，获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
# （-------判断是否是审核通过的用例，并且审核成功---------------）
if case["title"] == "审核通过" and res["msg"] == "OK":
# >>>>>>>>>>>(------将执行通过的标ID保存为类属性------------)
TestAudit.pass_loan_id = data["loan_id"]
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# ( >>>>>>>>>>>-----对需要进行数据库校验的用例，进行校验)
if case["check_sql"]:
sql = case["check_sql"].replace("#loan_id#", str(self.loan_id))
status = self.db.find_one(sql)["status"]
self.assertEqual(expected["status"], status)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_add(self, case):
# 1、准备用例数据
url = conf.get("env", "base_url") + case["url"]
method = case["method"]
# 准备用例参数
# 替换参数中的用户id
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 准备请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 加标之前，查询数据库中该用户标的数量
if case["check_sql"]:
sql = replace_data(case["check_sql"])
start_count = self.db.find_data_count(sql)
# 2、发送请求获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果:", res)
# 3、断言预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 判断是否需要进行sql校验
if case["check_sql"]:
# 加标之后
sql = replace_data(case["check_sql"])
end_count = self.db.find_data_count(sql)
self.assertEqual(1, end_count - start_count)
except AssertionError as e:
# 将结果写入日志中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
result = "未通过"
raise e
else:
# 结果写到日志
log.info("用例--{}--执行通过".format(case["title"]))
result = "通过"
finally:
# 将结果写入到excel中
self.excel.write_data(row=row, column=8, value=result)
def test_recharge(self, cas):
# 准备数据
url = conf.get('env', 'url') + cas['url']
cas['data'] = cas['data'].replace('#member_id#', self.member_id)
data = eval(cas['data'])
method = cas['method']
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = self.token
expected = eval(cas['expected'])
row = cas['case_id'] + 1
if cas['check_sql']:
sql = cas['check_sql'].format(self.member_id)
money_data = self.bb.find_one(sql)['leave_amount']
print("充值之前的钱：", money_data)
# 发送请求获取实际结果
repans = request(url=url, method=method, json=data, headers=headers)
res = repans.json()
if cas['check_sql']:
sql = cas['check_sql'].format(self.member_id)
money_data2 = self.bb.find_one(sql)['leave_amount']
print("充值之后的钱:", money_data2)
print('预期结果:', expected)
print('实际结果：', res)
# 断言
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if cas['check_sql']:
# 将准备的data数据中的amount数值类型转换为decimal
my_data = decimal.Decimal(str(data['amount']))
self.assertEqual(my_data, money_data2 - money_data)
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_register(self, cases):
# 第一步：准备用例数据
# 请求方法
method = cases["method"]
# 请求地址
url = cases["url"]
# 请求参数（参数化替换）
# 判断data中是否有需要替换的参数
if "#phone#" in cases["data"]:
phone = self.random_phone()
cases["data"] = cases["data"].replace("#phone#", phone)
data = eval(cases["data"])
# 请求头
headers = eval(conf.get("env", "headers"))
# 预期结果
expected = eval(cases["expected"])
# 用例所在行
row = cases["case_id"] + 1
# 调用接口请求
response = request(method=method, url=url, json=data, headers=headers)
# 获取实际结果
res = response.json()
print("预期结果为：", expected)
print("实际结果为：", res)
# 断言
try:
# 断言两个字段是否相同
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 判断是否需要数据库断言
if cases["check_sql"]:
sql = cases["check_sql"].replace("#phone#",
data["mobile_phone"])
res = self.db.find_count(sql)
self.assertEqual(1, res)
except AssertionError as e:
# 断言结果回写到excel中
log.error("用例---{}----执行未通过".format(cases["title"]))
log.debug("预期结果为：{}".format(expected))
log.debug("实际结果为：{}".format(res))
log.exception(e)
self.excel.write_excel(row=row, column=8, value="不通过")
# 抛出异常
raise e
else:
# 结果回写到excel中
log.info("用例---{}----执行通过".format(cases["title"]))
self.excel.write_excel(row=row, column=8, value="通过")
def test_add(self, case):
# 第一步：准备数据
# 请求方法
method = case["method"]
# 请求地址
url = os.path.join(conf.get("env", "BASE_URL")) + case["url"]
# 请求参数
data = eval(replace_data(case["data"]))
# 请求头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
# 预期结果
expected = eval(case["expected"])
log.info("--------预期结果：{}----------".format(expected))
# 回写的行
row = case["case_id"] + 1
# 数据库前置查询
if case["check_sql"]:
start_count = self.db.find_count(replace_data(case["check_sql"]))
# 第二步：接口调用
response = requests.request(method=method,
url=url,
json=data,
headers=headers)
# 实际结果
res = response.json()
log.info("--------实际结果：{}----------".format(res))
# 数据断言和数据库断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 数据库后置查询
if case["check_sql"]:
end_count = self.db.find_count(replace_data(case["check_sql"]))
self.assertEqual(1, end_count - start_count)
except AssertionError as e:
# 结果回写到excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_excel(row, 8, value="未通过")
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_excel(row, 8, value="通过")
def test_withdraw(self, cas):
# 准备用例数据
url = conf.get('env', 'url') + cas['url']
cas['data'] = cas['data'].replace('#member_id#', str(self.member_id))
data = eval(cas['data'])
method = cas['method']
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = self.token
expected = eval(cas['expected'])
row = cas['case_id'] + 1
# 查询取现之前的余额
if cas['check_sql']:
sql = cas['check_sql'].format(self.member_id)
start_money = self.bb.find_one(sql)['leave_amount']
print('取现前：', start_money)
# 发送请求
response1 = request(method=method, url=url, headers=headers, json=data)
res = response1.json()
print('实际结果：', res)
print('预期结果：', expected)
# 断言
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
# 查询请求之后的账户余额
if cas['check_sql']:
sql = cas['check_sql'].format(self.member_id)
end_money = self.bb.find_one(sql)['leave_amount']
print('取现后：', end_money)
# 用例数据中data，amount的数值类型转换
my_data = decimal.Decimal(str(data['amount']))
self.assertEqual(my_data, start_money - end_money)
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_audit(self, case):
# 第一步：准备测试数据
# 调用方法
method = case["method"]
# 调用地址
url = conf.get("env", "BASE_URL") + case["url"]
# 调用参数
data = eval(replace_data(case["data"]))
# 调用信息头
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "admin_token")
# 预期结果
expected = eval(case["expected"])
# 是否有数据库校验
if case["check_sql"]:
sql = replace_data(case["check_sql"])
start_count = self.db.find_count(sql)
# 回写的行
row = case["case_id"] + 1
# 第二步：接口调用
response = requests.request(method=method, url=url, json=data, headers=headers)
res = response.json()
if case["title"] == "审核通过" and res["msg"] == "OK":
# 判断有“审核通过”的案例，已经审核通过，保存项目id
setattr(EnvData, "pass_loan_id", str(data["loan_id"]))
print("------------------------",EnvData.pass_loan_id)
# 第三步：断言和回写
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 是否需要数据库校验
if case["check_sql"]:
sql = replace_data(case["check_sql"])
status = self.db.find_one(sql)["status"]
self.assertEqual(expected["status"], status)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_excel(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_excel(row=row, column=8, value="通过")
def test_getDiseaseList(self, case):
method, headers, url, data, row, expected = getdata(case)
data["UserGuid"] = login()
res = (request(url=url, method=method, data=data, headers=headers, verify=False)).json()
try:
self.assertEqual(expected, res["result"])
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_update_regname(self, case):
# 1、准备数据
url = conf.get("env", "base_url") + case["url"]
# 判断是否有昵称需要替换
if "#reg_name#" in case["data"]:
# 随机生成一个昵称
reg_name = self.random_name()
# print(reg_name)
# 将参数中的#reg_name#替换成随机生成的昵称
case["data"] = replace_data(case["data"])
# 替换用户id
data = replace_data(case["data"])
data = eval(data)
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 2、发起请求，获取实际结果
response = request(url=url, method="patch", headers=headers, json=data)
res = response.json()
# 3、断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 对需要进行数据库校验的用例进行校验
if case["check_sql"]:
sql = replace_data(case["check_sql"])
new_regname = self.db.find_one_data(sql)["reg_name"]
self.assertEqual(reg_name, new_regname)
except AssertionError as e:
# 结果写进日志和excel中
log.error("用例--{}--执行未通过")
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
result = "未通过"
log.exception(e)
else:
log.info("用例--{}--执行通过".format(case["title"]))
result = "通过"
finally:
self.excel.write_data(row=row, column=8, value=result)
def test_audit(self, cas):
# 准备数据
url = conf.get('env', 'url') + cas['url']
# 判断是否需要替换为审核通过的标id
if "#pass_loan_id#" in cas['data']:
cas['data'] = replace_data(cas['data'])
cas['data'] = replace_data(cas['data'])
data = eval(cas['data'])
method = cas['method']
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = getattr(EnvData, 'admin_token')
expected = eval(cas['expected'])
row = cas['case_id'] + 1
# 获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
rese = response.json()
print('预期结果：', expected)
print('实际结果：', rese)
# 判断是否是审核通过的用例，并且审核成功
if cas['title'] == '审核通过' and rese['msg'] == 'OK':
setattr(EnvData, 'pass_loan_id', str(data['loan_id']))
try:
self.assertEqual(expected['code'], rese['code'])
self.assertEqual(expected['msg'], rese['msg'])
if cas['check_sql']:
sql = replace_data(cas['check_sql'])
status = self.bb.find_one(sql)['status']
self.assertEqual(expected['status'], status)
print(status, type(status))
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(rese))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_add(self, cas):
# 准备用例数据
url = conf.get('env', 'url') + cas['url']
cas['data'] = replace_data(cas['data'])
data = eval(cas['data'])
method = cas['method']
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = getattr(EnvData, 'token')
expected = eval(cas['expected'])
row = cas['case_id'] + 1
# 请求之前查询用户标的数量
if cas['check_sql']:
sql = replace_data(cas['check_sql'])
st = self.bb.find_count(sql)
print('请求之前的标数：', st)
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
print('预期结果：', expected)
print('实际结果：', res)
# 请求后查询用户标的数量
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if cas['check_sql']:
sql = replace_data(cas['check_sql'])
end = self.bb.find_count(sql)
print('请求之后标数', end)
self.assertEqual(1, end - st)
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_invest(self, case):
"""投资用例"""
# 第一步：准备数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
headers = eval(conf.get("env", "headers"))
if case["interface"] != "login":
# 如果不是登录接口，则添加一个token
headers["Authorization"] = getattr(EnvData, "token")
data = eval(replace_data(case["data"]))
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取实际结果
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
if case["interface"] == "login":
# 如果是登录接口则提取用户id和token
member_id = str(jsonpath.jsonpath(res, "$..id")[0])
token = "Bearer" + " " + jsonpath.jsonpath(res, "$..token")[0]
setattr(EnvData, "member_id", member_id)
setattr(EnvData, "token", token)
if case["interface"] == "add":
# 如果是加标接口则提取标id进行保存
loan_id = str(jsonpath.jsonpath(res, "$..id")[0])
setattr(EnvData, "loan_id", loan_id)
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_invest(self, cas):
url = conf.get('env', 'url') + cas['url']
method = cas['method']
data = eval(replace_data(cas['data']))
headers = eval(conf.get('env', 'headers'))
if cas['interface'] != 'login':
#如果不是登录的接口需要添加token
headers['Authorization'] = getattr(EnvData, 'token')
expected = eval(cas['expected'])
row = cas['case_id'] + 1
respones = request(url=url, method=method, json=data, headers=headers)
res = respones.json()
if cas['interface'] == 'login':
#如果是登录接口，需要提取id和token
token = 'Bearer' + ' ' + jsonpath.jsonpath(res, '$..token')[0]
member_id = str(jsonpath.jsonpath(res, '$..id')[0])
setattr(EnvData, 'token', token)
setattr(EnvData, 'member_id', member_id)
if cas['interface'] == 'add':
#如果是加标接口，需要获取加标后的标id
loan_id = str(jsonpath.jsonpath(res, '$..id')[0])
setattr(EnvData, 'loan_id', loan_id)
print('预期结果：', expected)
print('实际结果：', res)
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
except AssertionError as e:
log.error('这是{}用例未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例{}通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
def test_importData(self, case):
se = Session()
# 准备用例数据
login_url = "http://doctor.yy365.cn/index/login"
login_data = {
"username": conf.get("test_data", "admin_user"),
"password": conf.get("test_data", "admin_pwd")
}
response = se.post(url=login_url, data=login_data)
url1 = conf.get("env", "url") + case["url"]
headers = {"Content-Type": "multipart/form-data"}
file = {
'file':
open(
r"C:\Users\Administrator\Desktop\Romens_Api_Test\data\891407.xls",
'rb')
}
response2 = se.post(url=url1,
files=file,
verify=False,
headers=headers)
res = response2.json()
row = case["case_id"] + 1
expected = eval(case["expected"])
try:
self.assertEqual(expected["status_code"], response2.status_code)
except AssertionError as e:
# 结果回写excel中
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
log.exception(e)
self.excel.write_data(row=row, column=8, value="未通过")
raise e
else:
# 结果回写excel中
log.info("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
def test_login(self, cases):
# 第一步：准备用例数据
# 请求方法
method = cases["method"]
# 请求地址
url = cases["url"]
# 请求参数
data = eval(cases["data"])
# 请求头
headers = eval(conf.get("env", "headers"))
# 预期结果
expected = eval(cases["expected"])
# 用例所在行
row = cases["case_id"] + 1
# 调用接口请求
response = request(method=method, url=url, json=data, headers=headers)
# 获取实际结果
res = response.json()
# print("预期结果为：", expected)
# print("实际结果为：", res)
# 断言
try:
# 断言两个字段是否相同
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
# 断言结果回写到excel中
log.error("用例---{}----执行未通过".format(cases["title"]))
log.debug("预期结果为：{}".format(expected))
log.debug("实际结果为：{}".format(res))
log.exception(e)
self.excel.write_excel(row=row, column=8, value="不通过")
# 抛出异常
raise e
else:
# 结果回写到excel中
log.info("用例---{}----执行通过".format(cases["title"]))
self.excel.write_excel(row=row, column=8, value="通过")
def test_login(self, case):
# 1、准备用例数据
# 请求方法
method = case["method"]
# 请求地址
url = case["url"]
# 请求参数
data = eval(case["data"])
# 请求头
headers = eval(conf.get("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 用例所在行
row = case["case_id"] + 1
# 2、发送请求获取实际结果
response = request(method=method, url=url, json=data, headers=headers)
# 获取实际结果
res = response.json()
print("预期结果：", expected)
print("实际结果：", res)
# 3、断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
# 记录日志
log.error("用例--{}--执行未通过".format(case["title"]))
log.debug("预期结果：{}".format(expected))
log.debug("实际结果：{}".format(res))
result = "未通过"
log.exception(e)
raise e
else:
log.info("用例--{}--执行通过".format(case["title"]))
result = "通过"
finally:
# 结果回写excel中
self.excel.write_data(row=row, column=8, value=result)
def test_register(self, cas):
expected = eval(cas['expected'])
method = cas['method']
# 用生成的随机手机号码替换#phon#
if '#phon#' in cas['data']:
phones = self.readom_phon()
cas['data'] = cas['data'].replace('#phon#', phones)
data = eval(cas['data'])
url = cas['url']
headers = eval(conf.get('env', 'headers'))
row = cas['case_id'] + 1
respons = request(method=method, url=url, json=data, headers=headers)
res = respons.json()
print('预期结果：', expected)
print('实际结果：', res)
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if cas['sql']:
qy = cas['sql'].replace('#phon#', data['mobile_phone'])
re = self.bb.find_one(qy)
self.assertTrue(re)
except AssertionError as e:
log.error('用例--{}--未通过'.format(cas['title']))
log.debug('预期结果{}'.format(expected))
log.debug('实际结果{}：'.format(res))
log.exception(e)
self.excel.write(row=row, column=8, value='不通过')
raise e
else:
log.info('用例--{}--通过'.format(cas['title']))
self.excel.write(row=row, column=8, value='通过')
