def test_case_login(self, case):
# 登录接口用例执行的逻辑
# 第一步：准备测试用例数据
url = case.url
data = eval(case.data)
method = case.method
excepted = eval(case.excepted)
row = case.case_id + 1
# 第二步：发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method, url=url, data=data)
# 获取返回的内容
res = response.json()
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(excepted, res)
except AssertionError as e:
# 测试用例未通过
# 获取当前用例所在行
self.excel.write_data(row=row, column=8, value='未通过')
log.debug('{}，该条用例执行未通过'.format(case.title))
raise e
else:
# 测试用例执行通过
self.excel.write_data(row=row, column=8, value='通过')
log.debug('{}，该条用例执行通过'.format(case.title))
def access_token(self, cases, url):
# url = case.url
sign = BaseFuntest.get_md5sheng(eval(cases))
log.info('签名是:{}'.format(sign))
cases = str(cases).replace('\'', '\"')
j = json.loads(cases)
j['sign'] = sign
log.info('转换为json的数据{}'.format(j))
data = eval(cases)['data']
datastr = str(data).replace('\'', '\"')
dataspace = str(datastr).replace(' ', '')
log.info('data是：{}'.format(dataspace))
pc = aes.PrpCrypt('C9C9F54F74BD35DE5242885762E99E8E') # 初始化密钥
e = pc.encrypt(dataspace) # 加密
print("加密:", e)
j['data'] = e
print('j是{}'.format(j))
k = str(j).replace('data', 'encrypt_data')
l = str(k).replace('\'', '\"')
cases = l
log.info('请求的参数是：{}'.format(cases))
# 第二步 发送请求，获取结果
log.info('正在请求地址{}'.format(url))
return cases, pc
#setattr(ConText, 'access_token', access_token)
# access_token = Access_Token()
def test_case_kuaidi(self, case):
# 登录接口用例执行的逻辑
# 第一步：准备测试用例数据
url = case.url
data = case.data
method = case.method
excepted = eval(case.excepted)
row = case.case_id + 1
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
# 第二步：发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method,
url=url,
data=data,
headers=headers)
# 获取返回的内容
res = json.loads(response.text)
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(excepted['EBusinessID'], res['EBusinessID'])
self.assertEqual(excepted['ShipperCode'], res['ShipperCode'])
self.assertEqual(excepted['State'], res['State'])
self.assertEqual(excepted['Success'], res['Success'])
except AssertionError as e:
# 测试用例未通过
# 获取当前用例所在行
self.excel.write_data(row=row, column=8, value='未通过')
log.debug('{}，该条用例执行未通过'.format(case.title))
raise e
else:
# 测试用例执行通过
self.excel.write_data(row=row, column=8, value='通过')
log.debug('{}，该条用例执行通过'.format(case.title))
def test_bidloan(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备用例数据
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
if "*memberId*" in case.data:
# 想要用户id不存在，先找到最大用户id，加1即可
member_id = self.mysql.find_one(
"select max(id) as memberId from member")[0]
case.data = case.data.replace("*memberId*", str(member_id + 1))
if "*loanId*" in case.data:
# 想要项目id不存在，先找到最大项目id，加1即可
loan_id = self.mysql.find_one(
"select max(id) as loanId from loan")[0]
case.data = case.data.replace("*loanId*", str(loan_id + 1))
if "*amount*" in case.data:
# 想要可投金额不足，先找到可投金额的最大值，加大值即可
sql = f"select Amount from loan where Id = {eval(case.data)['loanId']}"
case.data = case.data.replace(
"*amount*", str(self.mysql.find_one(sql)[0] + 1000))
# 未登录时投资竞标，没有返回码
if case.expected_code:
case.expected_code = str(case.expected_code)
def test_recharge(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备测试数据，替换动态参数
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
if "*amount*" in case.data:
# 充值金额不足时，需要先获取库中的值
sql = f"select LeaveAmount from member where MobilePhone = '{eval(case.data)['mobilephone']}'"
money = float(self.mysql.find_one(sql)[0])
case.data = case.data.replace("*amount*", str(money + 1000))
# 未登录时取现/充值，没有返回码
if case.expected_code:
expected_code = str(case.expected_code)
else:
expected_code = None
# 数据库校验
if case.check_sql:
case.check_sql = sub_conf(case.check_sql)
old_money = float(self.mysql.find_one(case.check_sql)[0])
def test_advertisespageId(self, case):
# 准备测试用例数据
url = case.url
# excepted = case.excepted
method = case.method
row = case.case_id + 1
headers = eval(case.headers)
# sql = case.check_sql
# 发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method, url=url, headers=headers)
# 获取返回的内容,该接口无返回参数，只需获取状态码即可
res = response.status_code
# 获取返回的内容
response = response.json()
# 比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(200, res)
# self.assertEqual(excepted,response)
print('实际该接口请求实际返回的状态码为:{}'.format(res))
except AssertionError as e:
# 测试用例未通过
# 获取当前用例所在行
self.excel.write_data(row=row, column=9, value='未通过')
log.debug('{}，该条用例执行未通过'.format(case.title))
raise e
else:
# 测试用例执行通过
self.excel.write_data(row=row, column=9, value='通过')
log.debug('{}，该条用例执行通过'.format(case.title))
def get_md5xiamen(dateSign):
# data字段的值进行排序
l_list = []
l = dateSign['data']
# data按照顺序读取
for d in sorted(l):
m = '{0}{1}{2}{3}{4}{5}{6}{7}'.format('\"', d, '\"', ':', '\"', l[d],
'\"', ',')
l_list.append(m)
l_list_string = "".join(l_list)
s_list = [] # 新建空列表，存储date的值
# 循环读取date中的值
for i in sorted(dateSign):
if i == 'data':
n = '{0}{1}'.format(i, '=')
s_list.append(n)
zifu01 = '{'
s_list.append(zifu01)
s_list.append(l_list_string)
zifu02 = '}'
s_list.append(zifu02)
zifu = "&"
s_list.append(zifu)
else:
s = '{0}{1}{2}{3}'.format(i, '=', dateSign[i], '&')
s_list.append(s)
# 列表转换为str
s_list_string = "".join(s_list)
signRegion_key = s_list_string + "key=2156B331D45F53B02BFF05C3942E60D1"
# 单引号转换为双引号
signRegion_test = signRegion_key.replace('\'', '\"')
# 空格替换
signRegion_test01 = signRegion_test.replace(': ', ':')
signRegion_test02 = signRegion_test01.replace(',}', '}')
signRegion = signRegion_test02.replace(', ', ',')
signRegionnew = signRegion.replace('\"biz_param\":\"', '\"biz_param\":')
signRegionnew01 = signRegionnew.replace('13709301823\"}\"',
'13709301823\"}')
log.info('加密的值为：{0}'.format(signRegionnew01))
print('加密的值为：{0}'.format(signRegionnew01))
m = hashlib.md5() # 创建md5对象
m.update(signRegionnew01.encode("utf8"))
sign = m.hexdigest()
up_sign = sign.upper()
print('加密后的sign:{0}'.format(up_sign))
return up_sign
def test_audit(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备用例数据
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
if "*loanId*" in case.data:
# 想要项目id不存在，先找到最大项目id，加1即可
loan_id = self.mysql.find_one(
"select max(id) as loanId from loan")[0]
case.data = case.data.replace("*loanId*", str(loan_id + 1))
# 未登录时审核，没有返回码
if case.expected_code:
case.expected_code = str(case.expected_code)
def test_add(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备用例数据
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
if "*memberId*" in case.data:
# 想要用户id不存在，先找到最大用户id，加1即可
member_id = self.mysql.find_one(
"select max(id) as memberId from member")[0]
case.data = case.data.replace("*memberId*", str(member_id + 1))
# 未登录时新增项目，没有返回码
if case.expected_code:
case.expected_code = str(case.expected_code)
def test_register(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备测试数据，替换动态参数
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
# 第二步：发送请求到接口，获取实际结果
res_code = self.request.http_request(method=case.method,
url=self.url + case.url,
data=eval(case.data)).json()
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
if case.check_sql:
case.check_sql = case.check_sql.replace("*phone*", phone)
count = self.mysql.find_count(case.check_sql)
log.info(f"注册后数据库期望数据条数：1，注册后数据库实际数据条数：{count}")
self.assertEqual(1, count)
log.info(f"请求期望返回码：{eval(case.expected)}，请求实际返回码：{res_code}")
self.assertEqual(eval(case.expected), res_code)
def test_advertiseConfigs(self, case):
# 准备测试用例数据
url = case.url
# excepted = case.excepted
method = case.method
row = case.case_id + 1
headers = eval(case.headers)
# 发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method, url=url, headers=headers)
# 获取返回的内容,该接口无返回参数，只需获取状态码即可
res = response.status_code
# 比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(200, res)
if case.check_sql:
db_res = self.db.find_count(case.check_sql)
#如果数据库检索出条数，就与1比对
if db_res == 1:
self.assertEqual(1, db_res)
# 如果数据库检索不出条数，就与0比对
else:
self.assertEqual(0, db_res)
print('实际该接口查询的sql为:{}'.format(case.check_sql))
print('实际该接口执行sql查询出的数据条数为:{}'.format(db_res))
print('实际该接口请求实际返回的状态码为:{}'.format(res))
except AssertionError as e:
# 测试用例未通过
# 获取当前用例所在行
self.excel.write_data(row=row, column=9, value='未通过')
log.debug('{}，该条用例执行未通过'.format(case.title))
raise e
else:
# 测试用例执行通过
self.excel.write_data(row=row, column=9, value='通过')
log.debug('{}，该条用例执行通过'.format(case.title))
def test_getList(self, case):
log.info(f"验证接口：{case.interface}，接口url：{case.url}")
# 第一步：准备测试数据，替换动态参数
# 替换配置文件中的固定参数
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
if "*memberId*" in case.data:
# 想要用户id不存在，先找到最大用户id，加1即可
member_id = self.mysql.find_one("select max(id) from member")[0]
case.data = case.data.replace("*memberId*", str(member_id + 100))
if "*loanId*" in case.data:
# 想要项目id不存在，先找到最大项目id，加1即可
loan_id = self.mysql.find_one("select max(id) from loan")[0]
case.data = case.data.replace("*loanId*", str(loan_id + 100))
if case.check_sql:
# 生成回款计划前查找数据条数
case.check_sql = sub_conf(case.check_sql)
old_conut = self.mysql.find_count(case.check_sql)
def encryption_interface(self, cases):
sign = BaseFuntest.get_md5sheng(eval(cases))
log.info('签名是:{}'.format(sign))
cases = str(cases).replace('\'', '\"')
j = json.loads(cases)
j['sign'] = sign
log.info('转换为json的数据{}'.format(j))
data = eval(cases)['data']
datastr = str(data).replace('\'', '\"')
dataspace = str(datastr).replace(' ', '')
log.info('data是：{}'.format(dataspace))
pc = aes.PrpCrypt('C9C9F54F74BD35DE5242885762E99E8E') # 初始化密钥
e = pc.encrypt(dataspace) # 加密
print("加密:", e)
j['data'] = e
print('j是{}'.format(j))
k = str(j).replace('data', 'encrypt_data')
l = str(k).replace('\'', '\"')
cases = l
return cases
# from HTMLTestRunnerNew import HTMLTestRunner
from common.conifg import myconf
from common.constant import CASES_DIR
from common.constant import REPORT_DIR
from common.mylogger import log
import unittest
from common.BaseFuntest import excuteSuiteExportReport, analysisResult
import os
import shutil
"""
项目启动文件
"""
log.info('----------------------------------正在开启测试运行程序-------------------------------------------------')
# 第一步：创建测试套件
suite = unittest.TestSuite()
# 第二步：将用例添加到套件
loader = unittest.TestLoader()
suite.addTest(loader.discover(CASES_DIR))
# 第三步：执行用例，生成测试报告
# 读取配置文件中的report文件名
# report_name = myconf.get('report', file_name)
# 获取当前时间，拼接文件名称
filetime = time.strftime("%Y-%m-%d %H_%M_%S", time.localtime())
# filename = '{}report.html'.format(filetime)
class ConsumePointTestCase(unittest.TestCase):
"""try积分接口"""
excel = ReadExcel(data_file_path, 'consumePoint')
cases = excel.read_data_obj()
http = HTTPRequest()
db = ReadSQL()
@data(*cases)
def test_case_pointpark(self, case):
# 准备测试用例数据
url = case.url
# data = eval(case.data)
method = case.method
excepted = eval(case.excepted)
row = case.case_id + 1
headers = eval(case.headers)
# 处理case用例里需要替换的uid参数
# if '#uid#' in case.data:
# case.data = data_replace(case.data)
# 处理case用例里需要替换的serialNo参数
serialNo = self.random_serialNo()
if '*serialNo*' in case.data:
case.data = case.data.replace('*serialNo*', serialNo)
return case.data
# if 'point' in case.data:
# sql = "SELECT * FROM pointpark.point_activity_info where serialNo='{}'".format(serialNo)[8]
# if self.find_count(sql):
# excepted = case.data.replace('*point*',sql)
# return excepted
# 发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method,
url=url,
data=eval(case.data),
headers=headers)
# 获取返回的内容
res = response.json()
# 比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(excepted, res)
if case.check_sql:
db_res = self.db.find_count(case.check_sql)
self.assertEqual('1', db_res)
print('实际接口请求结果为:{}'.format(res))
print('预期接口请求结果为:{}'.format(excepted))
except AssertionError as e:
# 测试用例未通过
# 获取当前用例所在行
self.excel.write_data(row=row, column=9, value='未通过')
log.debug('{}，该条用例执行未通过'.format(case.title))
raise e
else:
# 测试用例执行通过
self.excel.write_data(row=row, column=9, value='通过')
log.debug('{}，该条用例执行通过'.format(case.title))
# data = eval(case.data)
method = case.method
excepted = eval(case.excepted)
row = case.case_id + 1
headers = eval(case.headers)
# 处理case用例里需要替换的uid参数
if "#uid#" in case.data:
case.data = data_replace(case.data)
# 处理case用例里需要替换的serialNo参数
serialNo = self.random_serialNo()
if "*serialNo*" in case.data:
case.data = case.data.replace("*serialNo*", serialNo)
# 发送请求到接口，获取结果
log.info('正在请求地址{}'.format(url))
response = self.http.request(method=method,
url=url,
data=eval(case.data),
headers=headers)
# 获取返回的内容
res = response.json()
# 比对预期结果和实际结果，断言用例是否通过
try:
self.assertEqual(excepted, res)
if case.check_sql:
db_res = self.db.find_count(case.check_sql)
self.assertEqual(1, db_res)
# print('实际接口请求结果为:{}'.format(res))
# print('预期接口请求结果为:{}'.format(excepted))
self.assertEqual(excepted, res)
case.data = sub_conf(case.data)
# 替换动态生成的参数
if "*phone*" in case.data:
# 注册时，手机号码为动态注册的号码
phone = random_phone()
case.data = case.data.replace("*phone*", phone)
# 第二步：发送请求到接口，获取实际结果
res_code = self.request.http_request(method=case.method,
url=self.url + case.url,
data=eval(case.data)).json()
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
if case.check_sql:
case.check_sql = case.check_sql.replace("*phone*", phone)
count = self.mysql.find_count(case.check_sql)
log.info(f"注册后数据库期望数据条数：1，注册后数据库实际数据条数：{count}")
self.assertEqual(1, count)
log.info(f"请求期望返回码：{eval(case.expected)}，请求实际返回码：{res_code}")
self.assertEqual(eval(case.expected), res_code)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
finally:
self.excel.write_data(row=case.code_id + 1, column=8, value=result)
log.info(f"测试用例【{case.title}】执行【{result}】")
def test_shengzhi_public(self,init,init1):
#print(case)
# 第一步：准备用例数据
# url = myconf.get('url', 'url') + case.url # 读取配置文件和Excel中的url地址进行拼接
# url = myconf.get('url', 'url')
#url = case.url
url = init[3][1]
# 替换用例参数
#case.json = data_replace(str(case.json))
json = data_replace(str(init[4][1]))
# if case.interface == '加密接口':
# case.json = Encryption_Interface().encryption_interface(case,case.json)
# sign = BaseFuntest.get_md5sheng(eval(case.json))
# log.info('签名是:{}'.format(sign))
# case.json = str(case.json).replace('\'', '\"')
# j = json.loads(case.json)
# j['sign'] = sign
# log.info('转换为json的数据{}'.format(j))
# data = eval(case.json)['data']
# datastr = str(data).replace('\'', '\"')
# dataspace = str(datastr).replace(' ', '')
# log.info('data是：{}'.format(dataspace))
# pc = aes.PrpCrypt('C9C9F54F74BD35DE5242885762E99E8E') # 初始化密钥
# e = pc.encrypt(dataspace) # 加密
# print("加密:", e)
# j['data']=e
# print('j是{}'.format(j))
# k = str(j).replace('data','encrypt_data')
# l = str(k).replace('\'', '\"')
# case.json = l
# if case.interface == '获取token':
json,pc = Access_Token().access_token(json,url)
# sign = BaseFuntest.get_md5sheng(eval(case.json))
# log.info('签名是:{}'.format(sign))
# case.json = str(case.json).replace('\'', '\"')
# j = json.loads(case.json)
# j['sign'] = sign
# log.info('转换为json的数据{}'.format(j))
# data = eval(case.json)['data']
# datastr = str(data).replace('\'', '\"')
# dataspace = str(datastr).replace(' ', '')
# log.info('data是：{}'.format(dataspace))
# pc = aes.PrpCrypt('C9C9F54F74BD35DE5242885762E99E8E') # 初始化密钥
# e = pc.encrypt(dataspace) # 加密
# print("加密:", e)
# j['data']=e
# print('j是{}'.format(j))
# k = str(j).replace('data','encrypt_data')
# l = str(k).replace('\'', '\"')
# case.json = l
# log.info('请求的参数是：{}'.format(case.json))
# # 第二步 发送请求，获取结果
# log.info('正在请求地址{}'.format(url))
response = init1.request(method=init[2][1], url=url, json=eval(json))
res = response.json()
log.info('返回的结果是:{}'.format(res))
datas_encrypt = res['encrypt_data']
log.info("datas_encrypt是：{}".format(datas_encrypt))
d = pc.decrypt(datas_encrypt) # 解密
bianma_d = d.encode().split(b'\x08\x08\x08\x08\x08\x08\x08\x08')
bianma_d_str = str(bianma_d)
bianma_d_str_de = bianma_d_str.replace("[b'","")
bianma_d_str_de_de = bianma_d_str_de.replace("', b'']","")
bianma_d_str_de_de_de = eval(bianma_d_str_de_de)
access_token = bianma_d_str_de_de_de['access_token']
log.info("access_token:{}".format(access_token))
# 将提取接口返回数据，保存为临时变量
setattr(ConText, 'access_token', access_token)
# json = eval(case.json)
# log.info('请求的参数是：{}'.format(str(case.json)))
# # 第二步 发送请求，获取结果
# log.info('正在请求地址{}'.format(url))
# response = self.http.request(method=case.method, url=url, json=eval(case.json))
# res = response.json()
# log.info('返回的结果是:{}'.format(res))
res_code = res['flag'] # 根据接口文档获取出来的是str格式
# 第三步 比对预期结果和实际结果
try:
# self.assertEqual(str(init[5][1]), res_code)
assert str(init[5][1]) == res_code,"实际结果与预期不符合"
except AssertionError as e:
# 用例执行未通过
# self.assertNotEqual(str(case.excepted), res_code)
# self.excel.write_data(row=case.case_id + 1, column=8, value='未通过')
log.info('{}:用例执行未通过'.format(init[0][1]))
log.info('请求的地址：{}'.format(url))
log.info('请求的参数是：{}'.format(json))
log.info('返回的结果是:{}'.format(res)) # 执行不通过返回对应结果到日志
log.exception(e)
raise e
else:
# self.excel.write_data(row=case.case_id + 1, column=8, value='通过')
log.info('{}:用例执行通过'.format(init[0][1]))
import unittest
import os
from HTMLTestRunnerNew import HTMLTestRunner
from common.mylogger import log
from common.constant import CASES_DIR,REPORT_DIR
log.info('-------------------开启测试运行程序--------------')
# 第一步创建测试套件
suite = unittest.TestSuite()
# 第二步 将用例添加到套件
loader = unittest.TestLoader()
suite.addTest(loader.discover(CASES_DIR))
# 拼接测试报告的路径
report_file_path = os.path.join(REPORT_DIR,'report.html')
# 第三步：执行用例,生成测试报告
with open(report_file_path,"wb") as fb:
runner = HTMLTestRunner(stream=fb,
verbosity=2,
title='快递鸟接口项目',
description="快递鸟接口项目",
tester="wyt")
runner.run(suite)
if case.interface == "注册":
# 注册后，将注册的账号和密码设置为缓存数据类的属性，以便其他用例读取
setattr(CacheData, "phone", phone)
setattr(CacheData, "pwd", "123qwe")
elif case.interface == "登录":
# 登录后后，将用户id设置为缓存数据类的属性，以便其他用例读取
sql = f"select id from member where MobilePhone='{getattr(CacheData, 'phone')}'"
setattr(CacheData, "memberId", str(self.mysql.find_one(sql)[0]))
elif case.interface == "加标":
# 加标成功后，将当前的loanId写入配置文件中以便后面验证使用
sql = f"select max(id) as loanId from loan where memberId = {eval(case.data)['memberId']}"
setattr(CacheData, "loanId", str(self.mysql.find_one(sql)[0]))
# 第三步：比对期望结果和实际结果，进行断言I
try:
log.info(f"请求期望返回码：{case.expected_code}，请求实际返回码：{res_code}")
self.assertEqual(case.expected_code, res_code)
if case.check_sql:
case.check_sql = sub_conf(case.check_sql)
count = self.mysql.find_count(case.check_sql)
log.info(f"竞标后数据库期望数据条数：1，竞标后数据库实际数据条数：{count}")
self.assertEqual(1, count)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
finally:
self.excel.write_data(row=case.code_id + 1, column=8, value=result)
log.info(f"测试用例【{case.title}】执行【{result}】")
setattr(CacheData, "pwd", "123qwe")
elif case.interface == "登录":
# 登录后后，将用户id设置为缓存数据类的属性，以便其他用例读取
sql = f"select id from member where MobilePhone='{getattr(CacheData, 'phone')}'"
setattr(CacheData, "memberId", str(self.mysql.find_one(sql)[0]))
elif case.interface == "加标":
# 加标成功后，将当前的loanId写入配置文件中以便后面验证使用
sql = f"select max(Id) from loan where MemberID = {eval(case.data)['memberId']}"
setattr(CacheData, "loanId", str(self.mysql.find_one(sql)[0]))
elif case.interface == "竞标":
# 竞标成功后，将当前的investId写入配置文件中以便后面验证使用
sql = f"select max(Id) from invest where MemberID = '{eval(case.data)['memberId']}' AND LoanId = '{getattr(CacheData, 'loanId')}'"
setattr(CacheData, "investId", str(self.mysql.find_one(sql)[0]))
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
log.info(f"请求期望返回码：{str(case.expected_code)}，请求实际返回码：{res_code}")
self.assertEqual(str(case.expected_code), res_code)
if case.check_sql:
new_conut = self.mysql.find_count(case.check_sql)
self.assertEqual(old_conut + 1, new_conut)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
finally:
self.excel.write_data(row=case.code_id + 1, column=8, value=result)
log.info(f"测试用例【{case.title}】执行【{result}】")
# @Author : 小坚强
# @StudentId : 2188
# @Time : 2019/8/31 9:50
import os
import unittest
from common.mylogger import log
from common.config import config
from pack_lib.HTMLTestRunnerNew import HTMLTestRunner
from common.constant import CASES_DIR, REPORT_DIR, TIME
"""项目启动文件"""
log.info("--------------正在开启测试运行程序--------------")
# 1、创建测试套件
suite = unittest.TestSuite()
# 2、将用例添加到测试套件中
loder = unittest.TestLoader()
suite.addTest(loder.discover(CASES_DIR, config.get("report", "case_name")))
# 3、执行测试用例，生成测试报告
with open(
os.path.join(REPORT_DIR,
TIME + "-" + config.get("report", "report_name")),
"wb") as file:
runner = HTMLTestRunner(stream=file,
verbosity=2,
title=config.get("report", "report_title"),
description=config.get("report", "report_des"),
tester=config.get("report", "report_tester"))
url=self.url + case.url,
data=eval(case.data)).json()["code"]
# 处理上下接口关联问题
if case.interface == "注册":
# 注册后，将注册的账号和密码设置为缓存数据类的属性，以便其他用例读取
setattr(CacheData, "phone", phone)
setattr(CacheData, "pwd", "123qwe")
elif case.interface == "登录":
# 登录后后，将用户id设置为缓存数据类的属性，以便其他用例读取
sql = f"select id from member where MobilePhone='{getattr(CacheData, 'phone')}'"
setattr(CacheData, "memberId", str(self.mysql.find_one(sql)[0]))
# 第三步：比对期望结果和实际结果，进行断言
try:
log.info(f"请求期望返回码：{case.expected_code}，请求实际返回码：{res_code}")
self.assertEqual(case.expected_code, res_code)
if case.check_sql:
new_count = self.mysql.find_count(case.check_sql)
log.info(f"加标该用户期望标数：{old_count + 1}，加标该用户实际标数：{new_count}")
self.assertEqual(old_count + 1, new_count)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
finally:
self.excel.write_data(row=case.code_id + 1, column=8, value=result)
log.info(f"测试用例【{case.title}】执行【{result}】")
if case.interface == "注册":
# 注册后，将注册的账号和密码设置为缓存数据类的属性，以便其他用例读取
setattr(CacheData, "phone", phone)
setattr(CacheData, "pwd", "123qwe")
elif case.interface == "登录":
# 登录后后，将用户id设置为缓存数据类的属性，以便其他用例读取
sql = f"select id from member where MobilePhone='{getattr(CacheData, 'phone')}'"
setattr(CacheData, "memberId", str(self.mysql.find_one(sql)[0]))
elif case.interface == "加标":
# 加标成功后，将当前的loanId写入配置文件中以便后面验证使用
sql = f"select max(id) as loanId from loan where memberId = {eval(case.data)['memberId']}"
setattr(CacheData, "loanId", str(self.mysql.find_one(sql)[0]))
# 第三步：比对期望结果和实际结果，进行断言I
try:
log.info(f"请求期望返回码：{case.expected_code}，请求实际返回码：{res_code}")
self.assertEqual(case.expected_code, res_code)
if case.check_sql:
case.check_sql = sub_conf(case.check_sql)
new_status = self.mysql.find_one(case.check_sql)[0]
log.info(
f"审核后该标期望状态：{eval(case.data)['status']}，审核后该标实际状态：{new_status}"
)
self.assertEqual(eval(case.data)["status"], new_status)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
finally:
"""
项目启动文件
"""
import unittest
from testcases import test_acquirecampaign
from pack_lib.HTMLTestRunnerNew import HTMLTestRunner
from common.mylogger import log
from common.constant import CASE_DIR, REPORT_DIR
import os
import time
from testcases.test_acquirecampaign import AdvertisesPageId, GetAdvertiseByCode, GetAdvertisesListByCodes, \
GetMaterialByCode, AdvertiseConfigs, GetAdvertiseConfigDetails, SUBT
log.info('---------正在开启测试运行程序----------')
now = time.strftime('%Y-%m-%d_%H_%M_%S')
#创建测试套件
suite = unittest.TestSuite()
#将用例添加到套件中
loader = unittest.TestLoader()
#执行testcases包下所有的用例
# suite.addTest(loader.discover(CASE_DIR))
#执行单条测试用例类
# suite.addTest(loader.loadTestsFromTestCase(AcquireCampaign))
# suite.addTest(loader.loadTestsFromTestCase(SendMsg))
# suite.addTest(loader.loadTestsFromTestCase(Registered_Log))
# suite.addTest(loader.loadTestsFromTestCase(GetByMobileAndAppName))
# suite.addTest(loader.loadTestsFromTestCase(GetByJxUidAndAppName))
suite.addTest(loader.loadTestsFromTestCase(SUBT))
# 第二步：发送请求到接口，获取实际结果
res_code = self.session.http_session(method=case.method,
url=self.url + case.url,
data=eval(
case.data)).json()["code"]
# 处理上下接口关联问题
if case.interface == "注册":
# 注册后，将注册的账号和密码设置为缓存数据类的属性，以便其他用例读取
setattr(CacheData, "phone", phone)
setattr(CacheData, "pwd", "123qwe")
# 第三步：比对预期结果和实际结果，断言用例是否通过
try:
log.info(f"请求期望返回码：{case.expected_code}，请求实际返回码：{res_code}")
self.assertEqual(expected_code, res_code)
if case.check_sql:
new_money = float(self.mysql.find_one(case.check_sql)[0])
log.info(f"充值/取现后金额为：{new_money}，充值/取现前金额为：{old_money}")
if case.interface == "充值":
expected = old_money + eval(case.data)["amount"]
elif case.interface == "取现":
expected = old_money - eval(case.data)["amount"]
self.assertEqual(expected, new_money)
except AssertionError as e:
result = "未通过"
log.exception(e)
raise e
else:
result = "通过"
