def replace_data(self, data):
param1 = '#(.+?)#' # 匹配规则1
param2 = '%(.+?)%' # 匹配规则2
while re.search(param1, data): # 如果从data中能匹配的到，循环
rd1 = re.search(param1, data) # 匹配到的内容1
rdata1 = rd1.group() # 匹配到的要被替换的数据
key1 = rd1.group(1) # 获取数据的键
if self.section1:
value1 = ob.getstr(self.section1, key1) # 获取配置文件存储的值
else:
value1 = getattr(ConText, key1)
data = data.replace(rdata1, str(value1)) # 替换数据
while re.search(param2, data): # 如果从data中能匹配的到，循环
rd2 = re.search(param2, data) # 匹配到的内容2
rdata2 = rd2.group() # 匹配到的要被替换的数据
key2 = rd2.group(1) # 获取数据的键
if self.section2:
value2 = ob.getstr(self.section2, key2) # 获取配置文件存储的值
else:
value2 = getattr(ConText, key2)
data = re.sub(rdata2, str(value2), data) # 替换数据
return data # 如果匹配不到直接返回数据
def setUpClass(cls):
url = ob.getstr('url', 'url') + '/member/login'
phone = ob.getstr('login', 'phone')
pwd = ob.getstr('login', 'pwd')
login_data = {"mobilephone": phone, "pwd": pwd} # 登录数据
print('{}测试开始执行'.format(cls))
cls.login = HttpSession(url=url, data=login_data).httprequest(
method='post') # 登录
cls.ms = ObMysql() # 创建数据库操作对象，打开数据库
cls.mylog1.info('-----充值提现模块开始测试-----')
def register(self):
'''注册'''
url = "http://test.lemonban.com/futureloan/mvc/api/member/register"
phone = ob.getstr('register', 'phone')
pwd = ob.getstr('register', 'pwd')
data = {"mobilephone": phone, "pwd": pwd, "regname": "zhaojian"}
HttpSession(url=url, data=data).httprequest(method='post') # 发送请求
setattr(ConText, "phone", phone) # 将注册之后的手机号码临时变量当中
setattr(ConText, "pwd", pwd) # 将注册之后的密码临时变量当中
memerid = self.mysql.select(
'SELECT id FROM member WHERE MobilePhone="{}"'.format(phone))[0][0]
setattr(ConText, "memberId", memerid) # 将注册之后的用户id写到临时变量当中
update_phone() # 更新配置文件的手机号码
def test(self, items):
self.pr.sendMCode() # 发送短信验证码
rp = Replace() # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
data = items.data # 获取数据
title = items.title # 获取用例标题
if "@verify_code@" in data:
verify_code = int(getattr(ConText, 'verify_code')) + 1
data = data.replace("@verify_code@",
str(verify_code)) # 用最新的验证码去替换
if title == '验证码超时':
verify_code = ob.getstr("verify_phone",
"verify_code") # 拿到已经超时的验证码
phone = ob.getstr("verify_phone", "phone") # 拿到发送的手机号
data = data.replace("<verify_code>", verify_code) # 替换验证码
data = data.replace("<phone>", phone) # 替换手机号码
client = Client(url) # 创建连接
data = eval(rp.replace_data(data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result) # 获取预期结果,并转换为字典
print('第{}条测试用例：{}开始执行'.format(case_id, title))
re = client.service.userRegister(data) # 发送请求
acl_re = str(re.retCode) # 获取实际结果
print('实际结果:{}'.format(except_result), type(except_result))
print('预期结果:{}'.format(acl_re), type(acl_re))
print(dict(re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
re_username = data["user_id"] # 拿到注册过的用户名
re_phone = data["mobile"]
setattr(ConText, 're_username', re_username) # 将注册过后的用户名写进临时变量
setattr(ConText, 're_phone', re_phone) # 将注册过后的手机号码写进临时变量
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
def __init__(self):
# 建立数据库的链接
try:
self.conn = pymysql.connect(host=ob.getstr('mysql', 'host'),
user=ob.getstr('mysql', 'user'),
passwd=ob.getstr('mysql', 'passwd'),
port=ob.getint('mysql', 'port'),
database=ob.getstr(
'mysql', 'database'),
charset='utf8')
except Exception as e: # 报错给出提示
print('出错：{}'.format(e))
else:
# 获取操作游标
self.cursor = self.conn.cursor()
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if items.check_sql:
if items.interface == 'generateRepayments':
result1 = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 请求前数据表中记录的个数
if "@loanId@" in items.data:
max_loanId = self.mysql.select(sql="SELECT max(Id)From loan",
row=1)[0] # 查到loan表的最大标id
data = data.replace("@loanId@", str(max_loanId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
if items.check_sql: # 如果需要数据库校验
if items.interface == 'bidloan':
investId = self.mysql.select(
rp.replace_data(items.check_sql))[0][0] # 竞标得到investId
setattr(ConText, 'investId', investId) # 将investId写进常量类
if items.interface == 'generateRepayments':
select_result = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 得到投资之后结果
self.assertEqual(1,
select_result - result1) # 比对查询的结果与预期的结果
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def sendMCode(self):
mysql = ObMysql(database="sms_db_45")
url = "http://120.24.235.105:9010/sms-service-war-1.0/ws/smsFacade.ws?wsdl"
client = Client(url=url) # 建立连接
client_ip = ob.getstr('register', 'client_ip')
phone = ob.getstr('register', 'phone')
username = ob.getstr('register', 'username')
pwd = ob.getstr('register', 'pwd')
data = {"client_ip": client_ip, "tmpl_id": 1, "mobile": phone}
client.service.sendMCode(data) # 请求
verify_code = mysql.select(
"SELECT Fverify_code FROM t_mvcode_info_6 WHERE Fmobile_no= '{}'".
format(phone))[0][0] # 获取短信验证码
setattr(ConText, 'client_ip', client_ip) # 将ip地址添加到临时变量
setattr(ConText, 'phone', phone) # 将手机号添加到临时变量
setattr(ConText, 'username', username) # 将用户名添加到临时变量
setattr(ConText, 'pwd', pwd) # 密码添加到临时变量
setattr(ConText, 'verify_code', verify_code) # 将短信验证码添加到临时变量
mysql.close()
update_phone() # 更新配置文件
def test(self, items):
case_id = items.case_id # 获取case_id
title = items.title # 获取title
method = items.method # 获取请求方法
url = ob.getstr('url', 'url') + items.url # 获取url地址
rp = Replace(section2='login')
data = eval(rp.replace_data(items.data)) # 获取请求数据
except_result = str(items.except_result) # 获取预期结果
print('第{}条用例开始执行：{}'.format(case_id, title))
self.mylog1.info('第{}条用例开始执行：{}'.format(case_id, title)) # 打印日志
if items.check_sql: # 如果需要校验数据库
sql = rp.replace_data(items.check_sql) # 获取sql语句
select_result = self.ms.select(sql) # 充值或者取现前的查询结果
leave_amount = select_result[0][0] # 拿到充值或者取现前的账户余额
print(leave_amount)
res = HttpSession(
url=url, data=data).httprequest(method=method).json() # 请求
select_result1 = self.ms.select(sql) # 充值后的查询结果
if items.interface == 'recharge': # 如果为充值接口
except_leave_amount = leave_amount + Decimal(
str(data['amount'])) # 得到预期的充值之后的余额
elif items.interface == 'withdraw': # 如果为取现接口
except_leave_amount = leave_amount - Decimal(
str(data['amount'])) # 得到预期提现后的余额
leave_amount1 = select_result1[0][0] # 拿到充值或者提现后后的账户余额
print('充值或者取现前的账户余额为{}'.format(leave_amount))
print('预期的账户余额为{}'.format(except_leave_amount))
print('充值或者取现后的账户余额为{}'.format(leave_amount1))
else:
res = HttpSession(
url=url, data=data).httprequest(method=method).json() # 请求
res1 = res['code'] # 返回的状态码
print('实际结果为{}'.format(except_result))
print('预期结果为{}'.format(res1))
# 比对实际与预期结果
try:
self.assertEqual(res1, except_result)
if items.check_sql: # 如果需要校验数据库
self.assertEqual(except_leave_amount,
leave_amount1) # 比对预期的充值之后的余额与实际的账户余额
except AssertionError as e: # 若实际与预期不符
print('测试未通过')
self.excel.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
self.mylog1.error('测试未通过,未通过信息为：{}'.format(e)) # 打印日志
raise e # 抛出异常
else:
print('测试通过')
self.excel.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
self.mylog1.info('测试通过') # 打印日志
finally:
self.excel.write(row=case_id + 1, column=8, value=res1) # 回写实际结果
def test(self, items):
self.pr.userRegister() # 注册
rp = Replace(section1="userinfo") # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
data = items.data # 获取数据
title = items.title # 获取用例标题
if "@uid@" in data:
max_uid = self.mysql.select(rp.replace_data(items.check_sql))[0][0]
print(max_uid)
data = data.replace("@uid@", str(int(max_uid + 1))) # 用最新uid去替换
client = Client(url) # 创建连接
data = eval(rp.replace_data(data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result)
print('第{}条测试用例：{}开始执行'.format(case_id, title))
re = client.service.verifyUserAuth(data) # 发送请求
acl_re = str(re.retCode) # 获取实际结果
print('实际结果:{}'.format(except_result), type(except_result))
print('预期结果:{}'.format(acl_re), type(acl_re))
print(dict(re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
if items.title == "实名认证成功":
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if "@memberId@" in items.data:
max_memberId = self.mysql.select(sql="SELECT max(Id)From member",
row=1)[0] # 查到member表的最大标id
data = data.replace("@memberId@", str(max_memberId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def test(self, items):
case_id = items.case_id # 获取case_id
title = items.title # 获取title
method = items.method # 获取请求方法
url = ob.getstr('url', 'url') + items.url # 获取url地址
rp = Replace(section1='register', section2='login') # 创建替换对象
data = eval(rp.replace_data(items.data)) # 替换后的数据
except_result = items.except_result # 获取预期结果
print('第{}条用例开始执行：{}'.format(case_id, title))
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 打印日志
res = HttpRequest(url=url,
data=data).httprequest(method=method).content.decode(
'utf8') # 请求获取实际结果
print('实际结果为{}'.format(except_result))
print('预期结果为{}'.format(res))
# 比对实际与预期结果
try:
self.assertEqual(res, except_result)
if items.check_sql: # 如果需要数据库校验
sql = rp.replace_data(items.check_sql)
sql_result = self.ms.find_result(sql) # 数据库查询结果
if sql_result == 1: # 如果注册成功
ob.write('login', 'phone',
data['mobilephone']) # 将手机号写进配置文件
ob.write('login', 'pwd', data['pwd']) # 将密码写进配置文件
self.assertEqual(1, sql_result) # 比对查询结果
except AssertionError as e: # 若实际与预期不符
print('测试未通过')
self.excel.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
self.mylog.error('测试未通过,未通过信息为：{}'.format(e))
raise e # 抛出异常
else:
print('测试通过')
self.excel.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
self.mylog.info('测试通过') # 打印日志
finally:
self.excel.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def test(self, items):
rp = Replace(section1='register') # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
client = Client(url) # 创建连接
title = items.title # 获取用例标题
data = eval(rp.replace_data(items.data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result) # 获取预期结果
print('第{}条测试用例：{}开始执行'.format(case_id, title))
try:
re = client.service.sendMCode(data) # 发送请求
except suds.WebFault as e:
acl_re = str(e.fault.faultstring) # 请求有误，返回实际结果
else:
acl_re = str(re.retCode) # 请求通过, 返回实际结果
print('实际结果:{}'.format(except_result))
print('预期结果:{}'.format(acl_re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
class MyLog(object):
'''日志类'''
log_in = ob.getstr('loglevel', 'log_in') # 日志收集等级
ch_log_out = ob.getstr('loglevel', 'ch_log_out') # 控制台输出等级
fh_log_out = ob.getstr('loglevel', 'fh_log_out') # 文件输出等级
save_log = cons.LOGS_DIR # 日志文件存储位置
def __init__(self, logname):
'''
初始化
:param logname: 收集器的名字
'''
self.logname = logname
def mylog(self, level, msg):
'''
日志方法
:param level: 输出的等级
:param msg: 输出的信息
:return:
'''
logger = logging.getLogger(self.logname) # 创建收集器
logger.setLevel(self.log_in) # 设置收入日志的等级
formatter = logging.Formatter(
datefmt='%Y-%m-%d %H:%M:%S',
fmt='%(asctime)s-[%(filename)s-->line:%(lineno)d]'
'-%(levelname)s-%(name)s-日志输出的信息：'
'%(message)s')
now = time.strftime('%Y-%m-%d') # 获取一下当前的时间
ch = logging.StreamHandler() # 创建控制台输出渠道
ch.setLevel(self.ch_log_out) # 设置控制台输出日志等级
ch.setFormatter(formatter) # 设置控制台日志输出格式
logger.addHandler(ch) # 将控制台输出渠道添加到收集器当中
try:
path = os.path.join(self.save_log,
'log_{}.log'.format(now)) # 设置一下日志的存储路径
fh = logging.FileHandler(path, 'a',
encoding='utf8') # 创建日志输出到文件的渠道
except FileNotFoundError: # 若不存在文件夹创建log文件夹
os.mkdir(self.save_log)
path = os.path.join(self.save_log,
'log_{}.log'.format(now)) # 设置一下日志的存储路径
fh = logging.FileHandler(path, 'a',
encoding='utf8') # 创建日志输出到文件的渠道
fh.setLevel(self.fh_log_out) # 设置文件的输出日志等级
fh.setFormatter(formatter) # 设置文件的输出格式
logger.addHandler(fh) # 将文件输出渠道添加到收集器当中
if level == 'DEBUG': # 如果输出日志等级等于DEBUG调用debug输出方法
logger.debug(msg)
elif level == 'INFO': # 如果输出日志等级等于INFO调用info输出方法
logger.info(msg)
elif level == 'WARNING': # 如果输出日志等级等于WARNING调用warning输出方法
logger.warning(msg)
elif level == 'ERROR': # 如果输出日志等级等于ERROR调用error输出方法
logger.error(msg)
elif level == 'CRITICAL': # 如果输出日志等级等于CRITICAL调用critical输出方法
logger.critical(msg)
logger.removeHandler(ch) # 回收控制台渠道
logger.removeHandler(fh) # 回收文件渠道
def debug(self, msg):
'''
debug方法
:param msg: 输出的内容
:return:
'''
self.mylog("DEBUG", msg)
def info(self, msg):
'''
info方法
:param msg: 输出的内容
:return:
'''
self.mylog('INFO', msg)
def warning(self, msg):
'''
warning 方法
:param msg: 输出的内容
:return:
'''
self.mylog('WARNING', msg)
def error(self, msg):
'''
error方法
:param msg: 输出的内容
:return:
'''
self.mylog("ERROR", msg)
def critical(self, msg):
'''
critical方法
:param msg: 输出的内容
:return:
'''
self.mylog('CRITICAL', msg)
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if items.check_sql:
result1 = self.mysql.find_result(rp.replace_data(
items.check_sql)) # 查询投资之前invest投资该标记录的个数
amount = self.mysql.select(
"SELECT LeaveAmount FROM member WHERE MobilePhone= '{}'".
format(getattr(ConText, 'phone')))[0][0] # 查询投资用户投资之前的余额
if "@memberId@" in items.data:
max_memberid = self.mysql.select(sql="SELECT max(Id)From member",
row=1)[0] # 查到用户表的最大id
data = data.replace("@memberId@", str(max_memberid + 100))
if "@loanId@" in items.data:
max_loanId = self.mysql.select(sql="SELECT max(Id)From loan",
row=1)[0] # 查到loan表的最大标id
data = data.replace("@loanId@", str(max_loanId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
if items.check_sql: # 如果需要数据库校验
select_result = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 得到投资之后结果
amount1 = self.mysql.select(
"SELECT LeaveAmount FROM member WHERE MobilePhone= '{}'".
format(getattr(ConText, 'phone')))[0][0] # 查询投资用户投资之后的余额
bd_amount = Decimal(str(data['amount'])) # 拿到充值金额
self.assertEqual(1, select_result - result1) # 比对查询的结果与预期的结果
self.assertEqual(bd_amount,
amount - amount1) # 比对余额的减少是否与投资的金额相等
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果