def test_register(self,case):
# 使用正则，首先从数据库查找到最大手机号加1，通过正则替换excel中的参数---还需再改！！！
# if case.case_id == 1:
# # 从数据库找到最大手机号+1
# max_phone_old = mysql.fetch_one(sql)['mobilephone']
# max_phone = int(max_phone_old) + 1
# print("最大手机号是：",max_phone)
# # 新的手机号替换excel中的手机号
# phone = re.findall(pattern='\d{11}', string=case.data)[0] # 先从excel中取出手机号
# case.data = case.data.replace(phone,str(max_phone)) # replace替换
# 也可以不用正则，取出case.data字典里的手机号，直接赋值替换
data = json.loads(case.data) # 从excel中取到的data是一个字符串，loads() 把字符串序列化为字典
if data['mobilephone'] == '${register}': # 判断是否需要进行参数化
max_phone_new = int(max_phone_old) + 1 # 取到数据库里面最大的手机号码，进行加1
data['mobilephone'] = max_phone_new # 赋值替换excel中的手机号
resp = Request(method=case.method, url=case.url, data=data) # request请求时，data一定要是字典类型
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected, resp.get_text())
# 数据库校验
if resp_dict['code'] == 10001: # 注册成功的数据校验，判断数据库member表有这条数据
sql = 'select * from future.member where mobilephone = "{0}"'.format(max_phone_new)
member = self.mysql.fetch_one(sql) # member是字典类型
expected = max_phone_new
if member is not None: # 正常注册成功，不应该返回None
self.assertEqual(expected, member['mobilephone'])
else: # 返回None，代表注册成功之后但是数据库里面没有插入数据
print("注册失败，数据库没有插入数据")
def test_login(self, case):
data = json.loads(case.data)
resp = Request(method=case.method, url=case.url,
data=data) # 通过封装的Request类来完成接口的调用
print('test data:', data)
print('status_code:', resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected, resp.get_json_code())
def test_audit(self, case): # 用case变量接收传进来的数据
data = DoRegex.replace(case.data) # 参数化处理
data = json.loads(data) # 将测试数据由字符串序列化成字典
# 先判断有没有cookies
if hasattr(Context, 'cookies'): # 判断是否有cookies
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
# Request封装类请求
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies) # request请求时，data一定要是字典类型
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
# 优先判断响应返回的code是否与期望结果一致
self.assertEqual(case.expected, int(resp_dict['code']))
# 判断有没有cookies（有说明是登录接口）
if resp.get_cookies():
setattr(Context, 'cookies', resp.get_cookies()
) # --请求request拿到cookies --把cookies放到Context里
# 当创建标的成功时，根据借款人ID查看数据库loan表是否添加数据
if resp_dict['msg'] == "加标成功": # 新增标的成功的数据校验，判断数据库loan表有这条新增的数据
# 再次查询数据库，获取最新的最大标的loan各项信息
sql = "SELECT * FROM future.loan WHERE MemberID = {} ORDER BY Id DESC LIMIT 1;".format(
Context.loan_member_id)
loan = self.mysql.fetch_one(sql) # loan是字典类型
if loan is not None: # 正常加标成功，不应该返回None,管理员加标成功的数据库校验
max_loan_id_new = self.max_loan_id_old + 1
expected = max_loan_id_new # 期望结果：测试加标成功前的最大标的ID加上1
# 判断数据库里面的标的详情是否与测试数据一致
# 多个字段一致才assert通过
self.assertEqual(expected, loan['Id']) # 实际结果：数据库查询的最大标的ID
self.assertEqual(int(data['memberId']),
loan['MemberID']) # MemberID是借款人的ID，管理员登录进行操作
self.assertEqual(float(data['amount']), loan['Amount'])
self.assertEqual(data['title'], loan['Title'])
self.assertEqual(float(data['loanRate']), loan['LoanRate'])
self.assertEqual(data['loanTerm'], loan['LoanTerm'])
self.assertEqual(data['loanDateType'], loan['LoanDateType'])
self.assertEqual(data['repaymemtWay'], loan['RepaymemtWay'])
self.assertEqual(data['biddingDays'], loan['BiddingDays'])
self.assertEqual(1, loan['Status'])
print("测试加标后的最大标的ID是：", max_loan_id_new)
# 将创建成功的标的ID写入到上下文中，用于之后投资用
setattr(Context, 'loan_id',
str(loan['Id'])) # 放一个str类型的进去，以备后面正则替换
else: # 返回None，表示数据库里面没有插入数据，管理员加标测试失败
raise AssertionError
# 当审核成功，需校验数据库loan表中status字段更改
if case.url == '/loan/audit' and resp_dict['code'] == 10001:
sql = 'SELECT * FROM future.loan WHERE MemberID = {} ORDER BY CreateTime DESC LIMIT 1;'.format(
Context.loan_member_id)
loan = self.mysql.fetch_one(sql)
self.assertEqual(data['status'], loan['Status'])
def test_login(self,case):
register = int(self.max_phone)+1
data = re.sub(pattern='\$\{(.*?)\}', repl=str(register),string=case.data) # 使用正则匹配替换excel中的数据
print('data:',data)
data = json.loads(data) #将str反序列化为字典
resp = Request(method=case.method,url=case.url,data=data)
print("响应结果：",resp.get_status_code())
resp_dict = resp.get_json()
resp_text = json.dumps(resp_dict, ensure_ascii=False, indent=4)
print('response: ', resp_text) # 打印响应
#优先判断期望结果与实现结果
expected = json.loads(case.expected)
self.assertEqual(expected['code'],resp_dict['code'])
sql = 'select * from future.member where mobilephone = "{0}"'.format(str(register))
if resp_dict['msg'] == "注册成功": # 注册成功的数据校验，判断数据库有这条数据
expected = int(self.max_phone) + 1
member = self.mysql.fetch_one(sql)
if member is not None: # 正常注册成功就不应该返回None
self.assertEqual(expected,int(member['MobilePhone']))
TestResult = 'PASS'
do_excel.write_result_by_case_id('register',case.case_id,resp.get_text(),TestResult)
else: # 返回None则代表注册成功之后但是数据库里面没有插入数据
TestResult = 'Fail'
do_excel.write_result_by_case_id('register',case.case_id,resp.get_text(),TestResult)
raise AssertionError
else: #注册失败的数据校验，判断数据库没有这条数据，自己写
if resp_dict['msg'] == "手机号码已被注册":
expected = data['mobilephone']
mobilephone = self.mysql.fetch_one('select * from future.member where mobilephone = {0}'.format(expected))
if mobilephone is not None: # 若数据库里有这条数据，则说明该手机号已被注册，用例pass
self.assertEqual(expected,mobilephone['MobilePhone'])
TestResult = 'PASS'
do_excel.write_result_by_case_id('register',case.case_id,resp_text,TestResult)
else: # 若数据库里没有这条数据，则说明该手机号未被重复注册，用例fail
TestResult = 'Fail'
do_excel.write_result_by_case_id('register',case.case_id,resp_text,TestResult)
else: # 其他所有注册失败用例
expected = register
member = self.mysql.fetch_one(sql)
if member is None: # 查询数据库里没有这条数据，说明该手机号未被注册，用例pass
TestResult = 'PASS'
do_excel.write_result_by_case_id('register',case.case_id,resp.get_text(),TestResult)
else:
TestResult = 'Fail'
do_excel.write_result_by_case_id('register',case.case_id,resp.get_text(),TestResult)
# def tearDown(self):
# print('数据清除')
# @classmethod
# def tearDownClass(cls):
# mysql.close()
def tearDown(self):
self.mysql.close()
def test_getInvestsByMemberId(self, case):
data = DoRegex.replace(case.data) # 参数化处理
data = json.loads(data) # 将测试数据由字符串序列化成字典
if hasattr(Context, 'cookies'): # 判断是否有cookies
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
# Request封装类请求
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies)
resp_dict = resp.get_json() # 获取请求响应，字典
# 判断返回里面是否有cookies(有说明是登录接口)
if resp.get_cookies(): # 判断返回里面是否有cookies
setattr(Context, 'cookies', resp.get_cookies()) # 放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 数据库校验
if resp_dict['msg'] == "获取用户投资列表成功":
# 从数据库查invest表中某个用户的全部投资记录
sql_select_invest = "SELECT * FROM future.invest WHERE MemberID = {} ORDER BY Id DESC;".format(
Context.invest_member_id)
invest_list = self.mysql.fetch_all(sql_select_invest)
# 根据用户ID获取invest表中某个用户的投资记录的最大行数
sql_select_row = "SELECT COUNT(Id) FROM future.invest WHERE MemberID = {};".format(
Context.invest_member_id)
max_row = self.mysql.fetch_one(sql_select_row)['COUNT(Id)']
if invest_list is not None:
for i in range(0, max_row): # 每一行数据校验
MyLog.info("正在校验第{}行数据".format(i))
# 判断请求返回的数据详情与数据库里面的详情是否一致
# 多个字段一致才assert通过
self.assertEqual(int(resp_dict['data'][i]['id']),
invest_list[i]['Id'])
self.assertEqual(int(resp_dict['data'][i]['memberId']),
invest_list[i]['MemberID'])
self.assertEqual(int(resp_dict['data'][i]['loanId']),
invest_list[i]['LoanId'])
self.assertEqual(float(resp_dict['data'][i]['amount']),
invest_list[i]['Amount'])
self.assertEqual(int(resp_dict['data'][i]['isValid']),
invest_list[i]['IsValid'])
self.assertEqual(
resp_dict['data'][i]['createTime'][0:19],
invest_list[i]['CreateTime'].strftime(
"%Y-%m-%d %H:%M:%S"))
MyLog.info("校验结果：PASS")
def test_login(self,case):
data=json.loads(case.data) # 对取到的data做序列化
if data['mobilephone']=='${register}':
data['mobilephone']=max_phone-90000
resp = Request(method=case.method, url=case.url, data=data) # 通过封装的Request类来完成接口的调用
print('test data:',data)
print('status_code:', resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,resp.get_json_code())
# 注册成功，在数据库校验是否有这条数据
if resp.get_status_code() == "20010":
sql='select * from future.member where MobilePhone = "{0}"'.format(max_phone-90000)
expected = max_phone-90000
member=mysql.fetch_one(sql)
if member is not None:
self.assertEqual(expected,member["MobilePhone"])
else:
raise AssertionError
else:
print("注册失败！")
def test_list(self, case):
data = DoRegex.replace(case.data)
data = json.loads(data)
# 先判断有没有cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies')
else:
cookies = None
# 通过封装的Request类来完成接口的调用
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies)
# 判断返回里面是否有cookies(有说明是登录接口)
if resp.get_cookies():
setattr(Context, 'cookies', resp.get_cookies()) # cookies放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 完成数据库校验
if resp_dict['msg'] == "获取用户列表成功":
# 从数据库查到member表全部用户的信息
# member_list是一个列表，列表是按照用户ID顺序排序。其中的元素是一个个字典。
# resp_dict['data'] 也是一个列表，列表是按照用户ID顺序排序。其中的元素是一个个字典。
sql_select_member = "SELECT * FROM future.member WHERE Id != '' ORDER BY Id ASC;"
member_list = self.mysql.fetch_all(sql_select_member)
# 获取member表最大行数
sql_select_row = "SELECT COUNT(Id) FROM future.member;"
max_row = self.mysql.fetch_one(sql_select_row)['COUNT(Id)']
if member_list is not None: # 如果从数据库里面查询出来不是空
for i in range(0, max_row): # 每一行数据校验
# 判断请求返回的数据详情与数据库里面的详情是否与一致
# 多个字段一致才assert通过
self.assertEqual(resp_dict['data'][i]['id'],
member_list[i]['Id'])
self.assertEqual(resp_dict['data'][i]['mobilephone'],
member_list[i]['MobilePhone'])
self.assertEqual(resp_dict['data'][i]['pwd'],
member_list[i]['Pwd'])
self.assertEqual(resp_dict['data'][i]['regname'],
member_list[i]['RegName'])
self.assertEqual(
float(resp_dict['data'][i]['leaveamount']),
float(member_list[i]['LeaveAmount']))
self.assertEqual(
resp_dict['data'][i]['regtime'][0:19], member_list[i]
['RegTime'].strftime("%Y-%m-%d %H:%M:%S"))
self.assertEqual(int(resp_dict['data'][i]['type']),
member_list[i]['Type'])
def test_login(self, case):
data = json.loads(case.data)
logger1.my_logger.info('测试用例名称：{0}'.format(case.title))
logger1.my_logger.info('测试用例数据：{0}'.format(case.data))
resp = Request(method=case.method, url=case.url,
data=data) # 通过封装的Request类来完成接口的调用
logger1.my_logger.debug('status_code:{0}'.format(
resp.get_status_code())) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
try:
self.assertEqual(case.expected, resp.get_text())
except AssertionError as e:
logger1.my_logger.error('测试失败')
def test_add(self, case):
data = DoRegex.replace(case.data) # 通过正则取excel的数据，Context覆盖excel的数据
data = json.loads(data) # 从excel中取到的data是一个字符串，loads()把字符串序列化为字典
# --请求request拿到cookies
# 先判断有没有cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
# 通过封装的Request类来完成接口的调用
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies) # request请求时,data一定要是字典类型
# 判断有没有cookies（有说明是登录接口）
if resp.get_cookies(): # 判断返回里面是否有cookies
setattr(Context, 'cookies', resp.get_cookies()) # 放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 完成数据库校验
# 再次查询数据库，获取最新的最大标的loan各项信息
sql = "SELECT * FROM future.loan WHERE MemberID = {} ORDER BY Id DESC LIMIT 1;".format(
Context.loan_member_id)
loan = self.mysql.fetch_one(sql) # loan是字典类型
if resp_dict['msg'] == "加标成功": # 新增标的成功的数据校验，判断数据库loan表有这条新增的数据
if loan is not None: # 正常加标成功，不应该返回None
max_loan_id_new = self.max_loan_id_old + 1
expected = max_loan_id_new # 期望结果：测试加标成功前的最大标的ID加上1
# 判断数据库里面的标的详情是否与测试数据一致
# 多个字段一致才assert通过
self.assertEqual(expected, loan['Id']) # 实际结果：数据库查询的最大标的ID
self.assertEqual(int(data['memberId']),
loan['MemberID']) # MemberID是借款人的ID，管理员登录进行操作
self.assertEqual(float(data['amount']), loan['Amount'])
self.assertEqual(data['title'], loan['Title'])
self.assertEqual(float(data['loanRate']), loan['LoanRate'])
self.assertEqual(data['loanTerm'], loan['LoanTerm'])
self.assertEqual(data['loanDateType'], loan['LoanDateType'])
self.assertEqual(data['repaymemtWay'], loan['RepaymemtWay'])
self.assertEqual(data['biddingDays'], loan['BiddingDays'])
self.assertEqual(1, loan['Status'])
print("测试加标后的最大标的ID是：", max_loan_id_new)
else: # 返回None，表示数据库里面没有插入数据，管理员加标测试失败
raise AssertionError
elif resp_dict['code'] != '10001':
expected = self.max_loan_id_old # 期望结果：测试加标成功前的最大标的ID
self.assertEqual(expected, loan['Id'])
def test_recharge(self, case): # 用case变量接收传进来的数据
# 参数化处理
data = DoRegex.replace(case.data) # 通过正则取excel的数据，Context覆盖excel的数据
data = json.loads(data) # 从excel中取到的data是一个字符串，loads()把字符串序列化为字典
MyLog.info("正在执行第{}条用例：{}。".format(case.case_id, case.title))
MyLog.info("测试数据是{}".format(data))
# --请求request拿到cookies
# # 先判断有没有cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
# 通过封装的Request类来完成接口的调用
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies) # request请求时,data一定要是字典类型
# 判断有没有cookies（有说明是登录接口）
# --请求request拿到cookies --把cookies放到Context里
# if resp.get_cookies('JSESSIONID'):
# setattr(Context,'cookies',{'JSESSIONID':resp.get_cookies('JSESSIONID')})
if resp.get_cookies(): # 判断返回里面是否有cookies
setattr(Context, 'cookies', resp.get_cookies()) # 放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 完成数据库校验，判断充值成功之后账户余额增加正确，充值失败余额不变
# 通过数据库查可以看到充值前的余额，充值后的余额，excel中的case.data可以查到充值金额amount
# 数据库校验：期望的充值后的余额=充值金额+充值前的余额，实际的充值后的余额=查询数据库得到充值后的余额
leaveamount_new = mysql.fetch_one(sql) # 再次获取账户余额---测试充值后的余额
actual = float(
leaveamount_new['LeaveAmount']) # 实际的账户余额 = 查询数据库得到账户的余额
MyLog.info("测试{}后的余额是：{}元".format(case.title, actual))
if resp_dict['code'] == '10001' and resp_dict[
'msg'] == "充值成功": # 充值请求后的响应码是10001并且充值成功
amount = float(data['amount']) # 通过excel中的case.data可以查到充值金额amount
MyLog.info('充值金额是：{}元'.format(amount))
expected = float(self.leaveamount_old['LeaveAmount']
) + amount # 充值成功，期望的账户余额=充值前的余额+充值金额
self.assertEqual(expected, actual) # 判断期望结果与实际结果是否一致
MyLog.info("此次测试结果是：PASS")
elif resp_dict['code'] != '10001':
expected = float(self.leaveamount_old['LeaveAmount']
) # 充值失败，期望结果：账户余额不变，是充值前的余额
self.assertEqual(expected, actual) # 判断期望结果与实际结果是否一致
MyLog.info("此次测试结果是：PASS")
def test_recharge(self, case):
# 参数化处理
data = DoRegex.replace(case.data)
data = json.loads(data)
if hasattr(Context, 'cookies'): # 判断是否有cookies
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies) # 通过封装的Request类来完成接口的调用
# 判断有没有cookie
if resp.get_cookies(): # 判断返回里面是否有cookies
setattr(Context, 'cookies', resp.get_cookies()) # 放入到上下文中
print('status_code:', resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code 是否与期望结果一致
def test_charge(self,case):
# 对取到的数据，做参数化处理
data = DoRegex.replace(case.data)
data = json.loads(data)
print("===test data===",data)
if hasattr(Context,'cookies'): # 通过上下文判断，来赋值cookies
cookies=getattr(Context,'cookies')
else:
cookies = None
resp = Request(method=case.method, url=case.url, data=data,cookies=cookies) # 通过封装的Request类来完成接口的调用
# 判断有没有cookie，如果有cookies（也就是在登陆的时候获取到了cookie），就给上下问context，增加一个cookies属性，
# 将登陆获取到的cookies存储起来
if resp.get_cookies():
setattr(Context,'cookies',resp.get_cookies())
print('status_code:', resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,resp.get_json_code())
def test_withdraw(self, case):
data = DoRegex.replace(case.data)
data = json.loads(data)
# 先判断有没有cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies') # 获取放到上下文里面的cookies
else:
cookies = None
# 通过封装的Request类来完成接口的调用
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies) # request请求时,data一定要是字典类型
# 判断有没有cookies（有说明是登录接口）
# --请求request拿到cookies --把cookies放到Context里
if resp.get_cookies(): # 判断返回里面是否有cookies
setattr(Context, 'cookies', resp.get_cookies()) # 放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 完成数据库校验，判断取现成功之后账户余额增加正确，取现失败余额不变
# 通过数据库查可以看到取现前的余额，取现后的余额，excel中的case.data可以查到取现金额amount
# 数据库校验：期望的取现后的余额=取现前的余额-取现金额，实际的取现后的余额=查询数据库得到取现后的余额
leaveamount_new = self.mysql.fetch_one(
self.sql)['LeaveAmount'] # 再次获取账户余额---测试取现后的余额
actual = float(leaveamount_new) # 实际的账户余额 = 查询数据库得到账户的余额
print("测试{}后的余额是：{}元".format(case.title, actual))
if resp_dict['code'] == '10001' and resp_dict[
'msg'] == "取现成功": # 取现请求后的响应码是10001并且取现成功
amount = float(data['amount'])
print('取现金额是：{}元'.format(amount))
expected = float(
self.leaveamount_old) - amount # 取现成功，期望的账户余额=取现前的余额-取现金额
self.assertEqual(expected, actual) # 判断期望结果与实际结果是否一致
elif resp_dict['code'] != '10001':
expected = float(self.leaveamount_old) # 取现失败，期望结果：账户余额不变，是取现前的余额
self.assertEqual(expected, actual) # 判断期望结果与实际结果是否一致
def test_register(self, case):
data = json.loads(case.data) # 将字符串序列化为字典
if data['mobilephone'] == '${register}': # 判断是否是需要进行参数化
data['mobilephone'] = int(max_phone) + 1 # 取到数据库里面最大的手机号码进行加1
MyLog.info('测试用例名称：{0}'.format(case.title))
MyLog.info('测试用例数据：{0}'.format(case.data))
MyLog.error('测试用例数据error')
resp = Request(method=case.method, url=case.url,
data=data) # 通过封装的Request类来完成接口的调用
MyLog.debug('status_code:{0}'.format(resp.get_status_code()))
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected, resp.get_text())
if resp_dict['code'] == 20110: # 注册成功的数据校验，判断数据库有这条数据
sql = 'select * from future.member where mobilephone = "{0}"'.format(
max_phone)
expected = int(self.max_phone) + 1
member = self.mysql.fetch_one(sql)
if member is not None: # 正常注册成功就不应该返回None
self.assertEqual(expected, member['mobilephone'])
else: # 返回None则代表注册成功之后但是数据库里面没有插入数据
MyLog.error('注册失败')
raise AssertionError
def test_login(self, case):
data = DoRegex.replace(case.data) #用正则匹配替换
data = json.loads(data) #将str反序列化为字典
resp = Request(method=case.method, url=case.url, data=data)
print("响应结果：", resp.get_status_code())
resp_dict = resp.get_json()
resp_text = json.dumps(resp_dict, ensure_ascii=False, indent=4)
print('response: ', resp_text) # 打印响应
expect = json.loads(case.expected)
mobilephone = data['mobilephone']
sql_mobile = 'select * from future.member where mobilephone = {0}'.format(
mobilephone)
self.assertEqual(expect['code'], resp_dict['code'])
if resp_dict[
'msg'] == '登录成功': # 如果登录成功，校验数据库登录密码是否正确 没必要做这步 为了研究下MD5加密
member = mysql.fetch_one(sql_mobile)
if member is not None: # 如果数据库中存在，判断登录密码是否正确
# 明天接着写
#思路：针对登录失败 要判断
# 1.手机号未注册 -- 即查询不在数据库中
# 2. 密码与数据库中密码不匹配 研究下密码MD5加密处理
# 3. 其他失败场景不需校验数据库
sql_pwd = 'SELECT * from future.member where MobilePhone = {0}'.format(
mobilephone)
Pwd = mysql.fetch_one(sql_pwd)[
'Pwd'] # 查询该用户数据库中的密码为md5加密非明文密码
pwd_md5 = HashLib.md5_key(data['pwd']) # 获取传入明文密码进行md5加密
pwd_md5 = pwd_md5.swapcase() # 因数据库为大写，这里需要进行大小写互换
if pwd_md5 == Pwd:
TestResult = 'PASS'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(),
TestResult)
else: # 密码不匹配，登录成功-- 异常场景
TestResult = 'Fail'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(),
TestResult)
else: # 返回None则代表登录成功之后但是数据库里面没有插入数据，抛出异常
TestResult = 'Fail'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(), TestResult)
raise AssertionError
elif resp_dict['msg'] == '重复注册': # 重复注册-->查询数据库有记录则pass，否则fail
member = mysql.fetch_one(sql_mobile)
if member is not None:
TestResult = 'PASS'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(), TestResult)
else:
TestResult = 'Fail'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(), TestResult)
raise AssertionError
else: # 其他异常不需数据库校验
try:
self.assertEqual(case.expected, resp.get_text())
TestResult = 'PASS'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(), TestResult)
except AssertionError as e:
TestResult = 'Fail'
do_excel.write_result_by_case_id('login', case.case_id,
resp.get_text(), TestResult)
raise e
print('comming')
# 测试一下DoExcel类
do_excel = DoExcel('../datas/cases.xlsx') # 实例化一个DoExcel对象
sheet_names = do_excel.get_sheet_names() # 获取到work boot里面所有的sheet名称的列表
print("sheet 名称列表：", sheet_names)
case_list = ['login', 'register'] # 定义一个执行测试用例的列表
for sheet_name in sheet_names:
if sheet_name in case_list: # 如果当前的这个sheet_name 不在可执行的case_list里面，就不执行
cases = do_excel.get_cases(sheet_name)
print(sheet_name + ' 测试用例个数：', len(cases))
for case in cases: # 遍历测试用例列表，每进for一次，就取一个case实例
print("case信息：", case.__dict__) # 打印case信息
data = eval(case.data) # Excel里面取到data是一个字符串，使用eval函数将字符串转换成字典
resp = Request(method=case.method, url=case.url,
data=data) # 通过封装的Request类来完成接口的调用
print('status_code:', resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
# 通过json.dumps函数将字典转换成格式化后的字符串
resp_text = json.dumps(resp_dict, ensure_ascii=False, indent=4)
print('response: ', resp_text) # 打印响应
# 判断接口响应是否和Excel里面expected的值是否一致
if case.expected == resp.get_text():
print("result : PASS")
do_excel.write_back_by_case_id(
sheet_name=sheet_name,
case_id=case.case_id,
actual=resp.get_text(),
result='PASS') # 期望结果与实际结果一致，就写入PASS到result这个单元格
else:
print("result : FAIL")
do_excel.write_back_by_case_id(
def test_getLoanList(self, case):
data = DoRegex.replace(case.data) # 参数化处理
data = json.loads(data) # 字符串序列化为字典
# 先判断有没有cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies')
else:
cookies = None
# 通过封装的Request类来完成接口的调用
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies)
# 判断返回里面是否有cookies(有说明是登录接口)
if resp.get_cookies():
setattr(Context, 'cookies', resp.get_cookies()) # cookies放入到上下文中
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
self.assertEqual(case.expected,
int(resp_dict['code'])) # 判断返回的code是否与期望结果一致
# 完成数据库校验
if resp_dict['msg'] == "获取标列表成功":
# 从数据库查到loan表全部标的信息
# loan_list是一个列表，列表是按照标的ID顺序排序。其中的元素是一个个字典。
# resp_dict['data'] 也是一个列表，列表是按照标的ID顺序排序。其中的元素是一个个字典。
sql_select_loan = "SELECT * FROM future.loan WHERE Id != '' ORDER BY Id ASC;"
loan_list = self.mysql.fetch_all(sql_select_loan)
# 获取loan表最大行数
sql_select_row = "SELECT COUNT(Id) FROM future.loan;"
max_row = self.mysql.fetch_one(sql_select_row)['COUNT(Id)']
if loan_list is not None: # 如果从数据库里面查询出来不是空
for i in range(0, max_row): # 每一行数据校验
# 判断数据库里面的标的详情是否与请求返回的数据详情一致
# 多个字段一致才assert通过
self.assertEqual(int(resp_dict['data'][i]['id']),
loan_list[i]['Id'])
self.assertEqual(int(resp_dict['data'][i]['memberId']),
loan_list[i]['MemberID'])
self.assertEqual(resp_dict['data'][i]['title'],
loan_list[i]['Title'])
self.assertEqual(float(resp_dict['data'][i]['amount']),
float(loan_list[i]['Amount']))
self.assertEqual(float(resp_dict['data'][i]['loanRate']),
float(loan_list[i]['LoanRate']))
self.assertEqual(int(resp_dict['data'][i]['loanTerm']),
loan_list[i]['LoanTerm'])
self.assertEqual(int(resp_dict['data'][i]['loanDateType']),
loan_list[i]['LoanDateType'])
self.assertEqual(int(resp_dict['data'][i]['repaymemtWay']),
loan_list[i]['RepaymemtWay'])
self.assertEqual(int(resp_dict['data'][i]['biddingDays']),
loan_list[i]['BiddingDays'])
self.assertEqual(int(resp_dict['data'][i]['status']),
loan_list[i]['Status'])
self.assertEqual(
resp_dict['data'][i]['createTime'][0:19], loan_list[i]
['CreateTime'].strftime("%Y-%m-%d %H:%M:%S"))
# 时间是空值时，怎么校验？？？
# self.assertEqual(resp_dict['data'][i]['biddingStartTime'][0:19], loan_list[i]['BiddingStartTime'].strftime("%Y-%m-%d %H:%M:%S"))
# self.assertEqual(resp_dict['data'][i]['fullTime'][0:19],loan_list[i]['FullTime'].strftime("%Y-%m-%d %H:%M:%S"))
MyLog.info("正在校验数据库第{}行数据，结果：PASS".format(i + 1))
file_name = os.path.join(contants.datas_dir, 'test_cases.xlsx')
do_excel = DoExcel(file_name)
sheet_names = do_excel.get_sheet_names() # 获取到所有的sheet名称的列表
print("sheet 名称列表：", sheet_names)
case_list = ["register", "login"] # 定义执行的sheet列表
for sheet_name in sheet_names:
if sheet_name in case_list: # 如果sheet_name在list中，就执行
cases = do_excel.get_cases(sheet_name)
print(sheet_name + "测试用例个数：", len(cases))
for case in cases: # 遍历测试用例列表，for一次，则去一个case实例
print('cases:', case.__dict__) # 打印case信息
data = eval(case.data) # 渠道data字符串，然后转化成字典
res = Request(method=case.method, url=case.url,
data=data) # 接口调用
print("status_code:", res.get_status_code())
res_dict = res.get_json() # 获取请求响应：字典
# 把字段转化成格式化的字符串
res_text = json.dumps(res_dict, ensure_ascii=False, indent=4)
print("response:", res_text) # 打印响应
do_excel.write_actual_by_case_id(sheet_name=sheet_name,
case_id=case.case_id,
actual=res.get_text())
if case.expected == res.get_text():
print("result : PASS")
do_excel.write_result_by_case_id(sheet_name=sheet_name,
case_id=case.case_id,
result='PASS')
else:
print("result : FAIL")
def test_recharge(self, case):
#参数化
register = int(max_phone) + 1
data = DoRegex.replace(case.data) #正则 查找并替换$表达式
data = re.sub(pattern='\#\{(.*?)\}', repl=str(register),
string=data) # 使用正则匹配替换#表达式register
data = json.loads(data) #将str反序列化为字典
#处理cookies
if hasattr(Context, 'cookies'):
cookies = getattr(Context, 'cookies')
else:
cookies = None
resp = Request(method=case.method,
url=case.url,
data=data,
cookies=cookies)
#判断有没有cookies，动态获取cookies
if resp.get_cookies():
setattr(Context, 'cookies', resp.get_cookies())
print("请求响应结果：", resp.get_status_code())
resp_dict = resp.get_json()
resp_text = json.dumps(resp_dict, ensure_ascii=False, indent=4)
print('response: ', resp_text) # 打印响应
# 请求完后后，优先判断返回code
self.assertEqual(case.expected, int(resp_dict['code']))
actural = mysql.fetch_one(
self.select_member)['LeaveAmount'] # 查询数据库中该用户的实际余额
if resp_dict['msg'] == '登录成功':
try:
self.assertEqual(case.expected, eval(resp_dict['code']))
TestResult = 'PASS'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
except AssertionError as e:
TestResult = 'Fail'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
raise e
# 充值需要校验数据库,查询数据库中的 leaveamount是否与实际金额一致
elif resp_dict['msg'] == '充值成功':
expected = self.before_amount + int(
data['amount']) # 充值成功余额 = 充值前+充值金额
self.assertEqual(expected, actural)
TestResult = 'PASS'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
elif resp_dict['msg'] == '此手机号对应的会员不存在':
sql_member = 'select * from future.member where mobilephone = {0}'.format(
register)
member = mysql.fetch_one(sql_member)
if member is None: # 如果数据中不存在，表示未被注册，无法充值
TestResult = 'PASS'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
else:
TestResult = 'Fail'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
else: # 其他异常场景也需要校验数据库
try:
expected = self.before_amount # 充值失败 = 充值前
self.assertEqual(expected, actural)
TestResult = 'PASS'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
except AssertionError as e:
TestResult = 'Fail'
do_excel.write_result_by_case_id('recharge', case.case_id,
resp.get_text(), TestResult)
raise e
if __name__ == '__main__':
# 测试DoExcel类
do_excel = DoExcel(file_name='../datas/cases_v1.xlsx') # 实例化一个DoExcel对象
sheet_names = do_excel.get_sheet_names() # 获取到workbook里面所有的sheet名称的列表
print("sheet名称列表：", sheet_names)
case_list = ['register'] # 定义一个执行测试用例的列表
for sheet_name in sheet_names:
if sheet_name in case_list: # 当前的sheet_name不在可执行的case_list里面，就不执行
cases = do_excel.get_cases(sheet_name) # 测试用例列表,由一个个Case对象/实例组成
print(sheet_name + "测试用例个数：", len(cases))
for case in cases: # 遍历测试用例列表
print("case信息：", case.__dict__) # 打印case信息
data = eval(case.data) # 从excel中取到的data是一个字符串，把字符串转为字典
resp = Request(method=case.method, url=case.url, data=data)
print("status_code：", resp.get_status_code()) # 打印响应码
resp_dict = resp.get_json() # 获取请求响应，字典
print("resp_dict ：", resp_dict)
resp_text = json.dumps(resp_dict, ensure_ascii=False,
indent=4) # 将字典转化为字符串
print("response：", resp_text) # 打印响应
# 判断接口响应和excel里面expected的值是否一致
if case.expected == resp.get_text():
print("result: PASS")
# 期望结果与实际结果一致，就写入PASS到result这个单元格
do_excel.write_back_by_case_id(sheet_name=sheet_name,
case_id=case.case_id,
actual=resp.get_text(),
result='PASS')
else:
print("result: FAIL")
