def test_add(self, item):
url_add = self.base_url + item['url']
method = item['method']
# item['data'] = item['data'].replace('##member_id##', str(self.member_id))
# 调用封装的替换方法，用测试类对象的member_id值替换用例数据中的字符串
item['data'] = data_replace(item['data'], TestAdd)
params_add = eval(item['data'])
expected = eval(item['expected'])
sql = 'select * from futureloan.loan where member_id={}'.format(
self.member_id)
start_count = self.db.find_count(sql)
response_add = requests.request(method=method,
url=url_add,
json=params_add,
headers=self.headers)
res_add = response_add.json()
end_count = self.db.find_count(sql)
try:
assert_dict_in(expected, res_add)
if item['flag']:
self.assertEqual(1, end_count - start_count)
else:
self.assertEqual(0, end_count - start_count)
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行成功'.format(item['title']))
def test_login(self, item):
# 接口请求地址
url_login = self.base_url + item['url']
# 接口请求参数
params = eval(item['data'])
# 请求方法,并转换为小写
method = item['method'].lower()
# 从配置文件获取请求头
# 获取期望值
expected_login = eval(item['expected'])
# 请求接口，返回实际结果
response_login = requests.request(method=method,
url=url_login,
headers=self.headers,
json=params)
actual_login = response_login.json()
# 获取用例的行号
# row = item['case_id'] + 1
# 捕获异常
try:
assert_dict_in(expected_login, actual_login)
except AssertionError as e:
# 往Excel中写入执行结果
# self.excel.write_excel(row=row, column=6, value='失败', font=openpyxl.styles.Font(color='FF0000'))
# 往日志文件中写入执行结果
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
# self.excel.write_excel(row=row, column=6, value='通过', font=openpyxl.styles.Font(color='339966'))
log.info('这是【{}】用例执行通过'.format(item['title']))
def test_register(self, item):
url_recharge = self.base_url + item['url']
method = item['method'].lower()
# 用上面得到的用户id替换测试用例中的用户id
# item['data'] = item['data'].replace('##member_id##', str(self.member_id))
# 调用封装的替换方法，用测试类对象的member_id值替换用例数据中的字符串
item['data'] = data_replace(item['data'], TestRecharge)
params_recharge = eval(item['data'])
# %%%%%%%%%%%%%%%%%%%请求接口之前查询用户的余额%%%%%%%%%%%%%%%%
sql = 'SELECT leave_amount FROM futureloan.member WHERE id={}'.format(
self.member_id)
# %%%%%%%%%%%% 执行sql查询充值前余额%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
start_amount = self.db.find_one(sql)['leave_amount']
# 请求接口，获得返回值
response_recharge = requests.request(method,
url=url_recharge,
json=params_recharge,
headers=self.headers)
actual_recharge = response_recharge.json()
print(actual_recharge)
# %%%%%%%%%%%% 执行sql查询充值后余额%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
end_amount = self.db.find_one(sql)['leave_amount']
expected_recharge = eval(item['expected'])
try:
assert_dict_in(expected_recharge, actual_recharge)
# 运行成功的用例中，判断充值后的金额减去充值前的金额是否等于用例中的充值金额
if item['flag']:
self.assertEqual(params_recharge['amount'],
float(end_amount - start_amount))
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行通过'.format(item['title']))
def test_audit(self, item):
url_audit = self.base_url + item['url']
method = item['method']
expected = eval(item['expected'])
item['data'] = data_replace(item['data'], TestAudit)
params = eval(item['data'])
response_audit = requests.request(method=method,
url=url_audit,
json=params,
headers=self.headers_admin)
res_audit = response_audit.json()
print(res_audit)
if res_audit['msg'] == 'OK' and item['title'] == "审核通过":
TestAudit.pass_loan_id = params['loan_id']
# setattr(TestAudit,'pass_loan_id',params['loan_id'])
try:
self.assertEqual(expected['code'], res_audit['code'])
self.assertEqual(expected['msg'], res_audit['msg'])
if item['flag']:
sql = 'SELECT status FROM futureloan.loan WHERE id={}'.format(
self.loan_id)
status = self.db.find_one(sql)['status']
self.assertEqual(expected['status'], status)
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行成功'.format(item['title']))
def test_update(self, item):
url_update = self.base_url + item['url']
method_update = item['method'].lower()
# item['data'] = item['data'].replace('##member_id##', str(self.member_id))
# 调用封装的替换方法，用测试类对象的member_id值替换用例数据中的字符串
item['data'] = data_replace(item['data'], TestUpdate)
params_update = eval(item['data'])
response_update = requests.request(method=method_update,
url=url_update,
json=params_update,
headers=self.headers)
res_update = response_update.json()
sql = 'select * from futureloan.member where reg_name="{}"'.format(
params_update.get('reg_name', ""))
count = self.db.find_count(sql)
expected_update = eval(item['expected'])
try:
assert_dict_in(expected_update, res_update)
if item['flag']:
self.assertEqual(1, count)
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行成功'.format(item['title']))
def test_withdraw(self, item):
url_withdraw = self.base_url + item['url']
method = item['method'].lower()
# 用上面得到的用户id替换测试用例中的用户id
# item['data'] = item['data'].replace('##member_id##', str(self.member_id))
# 调用封装的替换方法，用测试类对象的member_id值替换用例数据中的字符串
item['data'] = data_replace(item['data'], TestWithdraw)
# 请求参数
params_withdraw = eval(item['data'])
# %%%%%%%%%%%%%%%%%%%请求接口之前查询用户的余额%%%%%%%%%%%%%%%%
sql = 'SELECT leave_amount FROM futureloan.member WHERE mobile_phone={}'.format(
conf.get('test_data', 'mobile_phone'))
# %%%%%%%%%%%%%%%%%%%请求接口之前查询用户的余额%%%%%%%%%%%%%%%%
start_amount = self.db.find_one(sql)['leave_amount']
# 请求接口，获得返回值
response_withdraw = requests.request(method,
url=url_withdraw,
json=params_withdraw,
headers=self.headers)
actual_withdraw = response_withdraw.json()
# %%%%%%%%%%%%%%%%%%%请求接口之前查询用户的余额%%%%%%%%%%%%%%%%
end_amount = self.db.find_one(sql)['leave_amount']
expected_withdraw = eval(item['expected'])
try:
assert_dict_in(expected_withdraw, actual_withdraw)
# 运行成功的用例中，判断提现前的金额减去提现后的金额是否等于用例中的提现金额
if item['flag']:
self.assertEqual(params_withdraw['amount'],
float(start_amount - end_amount))
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行通过'.format(item['title']))
def test_getinfo(self):
url_getinfo = self.base_url + '/member/{}/info'.format(self.member_id)
response = requests.get(url=url_getinfo, headers=self.headers)
actual = response.json()
expected = {"code": 0, "msg": "OK"}
try:
assert_dict_in(expected, actual)
except AssertionError as e:
log.error('获取用户信息失败')
log.exception(e)
raise e
else:
log.info('获取用户信息成功')
def test_join_course_failure(self, cases, stu_login_fixture):
driver = stu_login_fixture
# 学生加入课程
index_page = IndexPage(driver)
index_page.join_course(cases['course_code'])
actual = index_page.get_join_course_error()
try:
assert actual == cases['expected']
except AssertionError as e:
index_page.error_save_screenshot("加课用例断言失败")
log.error("————>执行失败")
log.exception(e)
raise e
else:
log.info("————>执行通过")
def test_assert_attend_num(self, teacher_login_fixture):
driver = teacher_login_fixture
index_page = IndexPage(driver)
index_page.course_name()
index_page.attend_attence()
l_attend_num = index_page.get_attendance_number()
index_page.close_attendance()
try:
assert int(l_attend_num) - int(TestAttendance.attend_number) == 1
except AssertionError as e:
log.error('【考勤成功的用例】------执行失败')
log.exception(e)
raise e
else:
log.info('【考勤成功的用例】------执行通过')
def execute_script(self, js, desc=None):
"""
执行js代码
:param js: js代码
:param desc: 元素的描述
:return:
"""
try:
self.driver.execute_script(js)
except Exception as e:
log.error('执行js--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('执行js--【{}】--成功'.format(desc))
def clear_input(self, loc, desc=None):
"""
清空输入框
:param loc: 输入框的定位器
:param desc: 元素描述
:return:
"""
try:
self.driver.find_element(*loc).clear()
except Exception as e:
log.error('清空输入框--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('清空输入框--【{}】--成功'.format(desc))
def switch_to_iframe_name(self, name, desc=None):
"""
通过frame标签的name属性进行iframe的切换
:param loc: 元素定位器
:param desc: 元素的描述
:return:
"""
try:
self.driver.switch_to.frame(name)
except Exception as e:
log.error('切换iframe--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('切换iframe--【{}】--成功'.format(desc))
def click_element(self, loc, desc=None):
"""
点击元素
:param loc: 元素定位器
:param desc: 元素描述
:return:
"""
try:
self.driver.find_element(*loc).click()
except Exception as e:
log.error('点击元素--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('点击元素--【{}】--成功'.format(desc))
def test_login_pass(self, cases, open_browser):
expect = cases['expected']
driver = open_browser
url = eval(conf.get('url', 'url'))
driver.get(url)
login_page = LoginPage(driver)
login_page.login(cases['mobile'], cases['pwd'])
index_page = IndexPage(driver)
res = index_page.is_login_success()
try:
assert res == expect
except AssertionError as e:
log.error('【登录成功的用例】————>执行失败')
log.exception(e)
raise e
else:
log.info('【登录成功的用例】————>执行通过')
def test_register(self, item):
# 第一步：准备用例数据
# 1、接口请求地址
url_register = self.base_url + item['url']
# 2、接口请求参数
if '##mobile_phone##' in item['data']:
# 给测试类TestRegister动态设置对象mobile_phone,且对象值为随机方法生成的数值
setattr(TestRegister, 'mobile_phone', self.random_phone())
# 调用封装的替换方法，用测试类对象的mobile_phone值替换用例数据中的字符串
item['data'] = data_replace(item['data'], TestRegister)
# phone = self.random_phone()
# item['data'] = item['data'].replace('##mobile_phone##', str(phone))
params = eval(item['data'])
print(params)
# 3、请求方法,并转换为小写
method = item['method'].lower()
# 4、从配置文件获取请求头
# 5、获取期望值
expected_register = eval(item['expected'])
# 第二步：请求接口，获取返回实际结果
response_register = requests.request(method,
url_register,
headers=self.headers,
json=params)
actual_register = response_register.json()
# 从数据库中查询注册数据数量,字典的get方法，在参数中查找键mobile_phone，找不到时用""替代
sql = 'select * from futureloan.member where mobile_phone="{}"'.format(
params.get('mobile_phone', ""))
res1 = self.db.find_count(sql)
# 第三步：断言，捕获异常
try:
# 断言实际结果是否包含预期结果
assert_dict_in(expected_register, actual_register)
# 判断用例是否需要进行数据库校验
if item['flag']:
# 从数据库中查询出的数据条数和1对比，如果有1条，则注册成功
self.assertEqual(1, res1)
except AssertionError as e:
# 往日志文件中写入执行结果
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行通过'.format(item['title']))
def input_send_keys(self, loc, value, desc=None):
"""
输入框，输入
:param loc: 输入框的定位器
:param value: 输入的内容
:param desc: 元素描述
:return:
"""
try:
self.driver.find_element(*loc).send_keys(value)
except Exception as e:
log.error('往输入框--【{}】--输入值失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('往输入框--【{}】--输入值成功'.format(desc))
def find_elements(self, loc, desc=None):
"""
查找元素
:param loc: 元素定位器
:param desc: 元素描述
:return:
"""
try:
eles = self.driver.find_elements(*loc)
except Exception as e:
log.error('查找元素--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('查找元素--【{}】--成功'.format(desc))
return eles
def get_element_text(self, loc, desc=None):
"""
获取元素的文本
:param loc: 输入框的定位器
:param desc: 元素描述
:return:
"""
try:
text = self.driver.find_element(*loc).text
except Exception as e:
log.error('获取元素--【{}】--文本失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('获取元素--【{}】--文本成功'.format(desc))
return text
def get_element_attribute(self, loc, attr, desc=None):
"""
获取元素的属性值
:param loc: 元素定位器
:param attr: 属性名
:param desc: 元素的描述
:return:
"""
try:
res = self.driver.find_element(*loc).get_attribute(attr)
except Exception as e:
log.error('获取元素--【{}】--属性值失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('获取元素--【{}】--属性值成功'.format(desc))
return res
def switch_to_iframe_loc(self, loc, desc=None):
"""
通过frame标签的定位表达式进行iframe的切换
:param loc: 元素定位器
:param desc: 元素的描述
:return:
"""
try:
WebDriverWait(self.driver, 0.5).until(
expected_conditions.frame_to_be_available_and_switch_to_it(
loc))
except Exception as e:
log.error('等待iframe可见并进行切换--【{}】--失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('等待iframe可见并进行切换--【{}】--成功'.format(desc))
def wait_element_clickable(self, loc, desc=None, timeout=20):
"""
等待元素可点击
:param loc: 元素定位器
:param desc: 元素的描述
:param timeout: 超时时间
:return:
"""
try:
ele = WebDriverWait(self.driver, timeout, 0.5).until(
expected_conditions.element_to_be_clickable(loc))
except Exception as e:
log.error('等待--【{}】--元素可点击失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('等待--【{}】--元素可点击成功'.format(desc))
return ele
def wait_element_exis(self, loc, desc=None, timeout=10):
"""
等待元素存在
:param loc: 元素定位器
:param desc: 元素的描述
:param timeout: 超时时间
:return:
"""
try:
ele = WebDriverWait(self.driver, timeout, 0.5).until(
expected_conditions.presence_of_element_located(loc))
except Exception as e:
log.error('等待--【{}】--元素存在失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('等待--【{}】--元素存在成功'.format(desc))
return ele
def open_new_window(self, desc=None):
"""
打开新窗口
:param desc: 元素的描述
:return:
"""
wins = self.driver.window_handles
try:
WebDriverWait(self.driver, 15, 0.5).until(
expected_conditions.new_window_is_opened(wins))
win = self.driver.window_handles
self.driver.switch_to.window(win[-1])
except Exception as e:
log.error('新窗口--【{}】--打开失败'.format(desc))
log.exception(e)
self.error_save_screenshot(desc)
raise e
else:
log.info('新窗口--【{}】--打卡成功'.format(desc))
def error_save_screenshot(self, desc):
"""
错误截图
:param desc: 图片的描述信息
:return:
"""
date = time.strftime("%Y-%m-%d_%H_%M_%S_")
filename = date + desc + '.png'
file_path = os.path.join(Error_Image_Path, filename)
try:
self.driver.save_screenshot(file_path)
except Exception as e:
log.error('对-【{}】--操作进行截图--失败'.format(desc))
log.exception(e)
raise e
else:
with open(file_path, 'rb') as f:
content = f.read()
allure.attach(content, '失败截图', allure.attachment_type.PNG)
log.info('对-【{}】--操作进行截图--成功'.format(desc))
log.info('图片名为{}'.format(file_path))
def test_invest(self, item):
url_invest = self.base_url + item['url']
method = item['method']
expected = eval(item['expected'])
item['data'] = data_replace(item['data'], TestInvest)
params = eval(item['data'])
# 在投资表里查询该项目投资前的数量
sql_invest = 'select * from futureloan.invest where loan_id={}'.format(self.loan_id)
count_start = self.db.find_count(sql_invest)
# 在用户表里查询投资用户投资前的可用余额
sql_amount = "select leave_amount from futureloan.member where id='{}'".format(self.member_id)
amount_start = self.db.find_one(sql_amount)['leave_amount']
# 在流水表中查询投资人在投资该项目前的数据数量
sql_finance = 'select * from futureloan.financelog where pay_member_id={}'.format(self.member_id)
cnt_start = self.db.find_count(sql_finance)
# 请求接口，获取响应值
response_invest = requests.request(method=method, url=url_invest, json=params, headers=self.headers)
res_invest = response_invest.json()
# 当用例数据的flag有值时，从投资响应结果中提取投资id，然后在回款列表查询回款记录数量
if item['flag']:
invest_id = jsonpath(res_invest, '$..id')[0]
sql_repay = 'select * from futureloan.repayment where invest_id={}'.format(invest_id)
self.count_repay = self.db.find_count(sql_repay)
# 在投资表里查询该项目投资后的数量
count_end = self.db.find_count(sql_invest)
# 在用户表里查询投资用户投资后的可用余额
amount_end = self.db.find_one(sql_amount)['leave_amount']
# 在流水表中查询投资人在投资该项目后的数据数量
cnt_end = self.db.find_count(sql_finance)
# 在项目表中，查询该项目的当前状态
sql_status = 'select status from futureloan.loan where id={}'.format(self.loan_id)
actual_status = self.db.find_one(sql_status)['status']
try:
self.assertEqual(expected['code'], res_invest['code'])
self.assertIn(expected['msg'], res_invest['msg'])
# 当运行第一条用例时，判断回款记录数是否和预期的数量一致
if self.casecnt == 1:
self.assertEqual(6, self.count_repay)
# 当用例数据的flag有值时，进行以下断言
if item['flag']:
# 断言投资成功后，投资表里有没有多1条数据
self.assertEqual(1, count_end - count_start)
# 断言投资成功后，用户投资前可用余额减去投资后可用余额是否等于投资金额
self.assertEqual(params['amount'], float(amount_start - amount_end))
# 断言投资成功后，流水表是不是多了一条数据
self.assertEqual(1, cnt_end - cnt_start)
# 断言投资成功后，项目的实际状态和预期状态是否一致
self.assertEqual(expected['status'], actual_status)
except AssertionError as e:
log.error('这是【{}】用例执行失败'.format(item['title']))
log.exception(e)
raise e
else:
log.info('这是【{}】用例执行成功'.format(item['title']))
