def create_logger():
"""创建日志收集器"""
# 1、创建收集器
log = logging.getLogger('test')
# 设置收集器日志的等级
log.setLevel(conf.get('logging', 'level'))
# 2、创建输出到文件的输出渠道（按时间轮转）
fh = TimedRotatingFileHandler(filename=os.path.join(
LOG_DIR, conf.get('logging', 'log_name')),
when='d',
interval=1,
backupCount=7,
encoding='utf-8')
# 设置输出等级
fh.setLevel(conf.get('logging', 'fh_level'))
# 添加到收集器中
log.addHandler(fh)
# 3、创建输出到控制台的输出渠道
sh = logging.StreamHandler()
# 设置输出等级
sh.setLevel(conf.get('logging', 'sh_level'))
# 添加到收集器中
log.addHandler(sh)
# 4、设置日志输出格式
formatter = "%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s"
mate = logging.Formatter(formatter)
fh.setFormatter(mate)
sh.setFormatter(mate)
return log
def create_logger():
"""
创建日志收集器
:return: 日志收集器
"""
# 第一步:创建一个日志收集器
log = logging.getLogger('ws')
# 第二步:设置收集器收集的等级
log.setLevel(conf.get('log', 'level'))
# 第三步: 设置输出渠道已经输出渠道的等级
fh = logging.FileHandler(log_filepath, encoding='utf8')
fh.setLevel(conf.get('log', 'fh_level'))
log.addHandler(fh)
sh = logging.StreamHandler()
sh.setLevel(conf.get('log', 'sh_level'))
log.addHandler(sh)
# 创建一个输出格式对象
formats = '%(asctime)s -- [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
form = logging.Formatter(formats)
# 将输出格式添加到输出渠道
fh.setFormatter(form)
sh.setFormatter(form)
return log
def test_update(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
data = eval(replace_data(case["data"]))
# 替换参数中的用户id
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(EnvData, "token_value")
# 在请求头中加入setupclass中提取出来的token
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
print("请求参数为:", data, type(data))
response = request(url=url, method=method, json=data, headers=headers)
res = response.json()
# 第三步：断言（比对预期结果和实际结果）
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
print("预期结果：", expected)
print("实际结果：", res)
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行通过".format(case["title"]))
class LoginPage(BasePage):
'''登录页面'''
# 登录url
url = conf.get('env', 'service') + conf.get('env', 'login_url')
def __init__(self, driver):
super().__init__(driver)
# 打开登录页面
self.driver.get(self.url)
self.driver.implicitly_wait(30)
def login(self, user, pwd):
'''输入账号密码等级登录'''
# 定位账号输入框
self.input_text(login_loc.mobile_ele_xpath, user, '输入账号')
# 定位密码输入框
self.input_text(login_loc.pwd_ele_xpath, pwd, '输入账号')
# 点击登录
self.click_element(login_loc.login_btn_xpath, '点击登录按钮')
def get_error_info(self):
'''获取错误信息'''
return self.wait_element_visibility(login_loc.error_info_xpath,
'登录-异常登录窗口错误信息').text
def get_alert_error_info(self):
'''获取页面弹窗的错误提示信息'''
return self.wait_element_visibility(login_loc.alert_error_info_xpath,
'登录-异常登录弹窗错误信息').text
def page_refresh(self):
'''刷新页面'''
self.driver.refresh()
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 invest_fixture():
"""投资用例的前置条件"""
driver = create_driver()
# 最大化窗口
driver.maximize_window()
# 设置隐式等待
driver.implicitly_wait(15)
# 实例登录页面对象
login_page = LoginPage(driver)
# 打开登录页面
login_page.open_login_page()
# 进行登录
login_page.login(mobile_phone=conf.get('test_data', 'mobile'),
pwd=conf.get('test_data', 'pwd'))
# 实例首页对象
index_page = IndexPage(driver)
# 首页点击投资
index_page.click_invest()
# 实例投资页面对象
invest_page = InvestPage(driver)
# 实例用户页面对象
user_page = UserPage(driver)
yield invest_page, user_page
driver.quit()
def test_loans(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
data = eval(replace_data(case["data"]))
# 替换参数中的用户id
headers = eval(conf.get("env", "headers"))
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
response = request(url=url, method=method, params=data, headers=headers)
res = response.json()
print(response.url)
# 第三步：断言（比对预期结果和实际结果）
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
# 断言返回的数据的条数
self.assertEqual(expected["len"],len(res["data"]))
except AssertionError as e:
# print("预期结果：", expected)
# print("实际结果：", res)
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行通过".format(case["title"]))
def create_logger():
# 第一步，创建一个日志收集器
log = logging.getLogger("dapang")
# 第二步，设置收集器收集的等级
log.setLevel(conf.get("log", "level"))
# 第三步，设置输出渠道
fh = logging.FileHandler(log_filepath, encoding="utf-8")
fh.setLevel(conf.get("log", "fh_level"))
log.addHandler(fh)
sh = logging.StreamHandler()
sh.setLevel(conf.get("log", "sh_level"))
log.addHandler(sh)
# 第四步，设置输出格式
# formats = '%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
# 创建一个输出格式对象
form = logging.Formatter(conf.get("log", "formats"))
# 将输出格式添加到输出渠道
fh.setFormatter(form)
sh.setFormatter(form)
return log
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 create_logger():
"""
创建日志收集器
:return: 日志收集器
"""
# 第一步：创建一个日志收集器
log = logging.getLogger("musen")
# 第二步：设置收集器收集的等级
log.setLevel(conf.get("log", "level"))
# 第三步：设置输出渠道以及输出渠道的等级
fh = logging.FileHandler(conf.get("log", "filename"), encoding="utf8")
fh.setLevel(conf.get("log", "fh_level"))
log.addHandler(fh)
sh = logging.StreamHandler()
sh.setLevel(conf.get("log", "sh_level"))
log.addHandler(sh)
# 创建一个输出格式对象
form = logging.Formatter(conf.get("log", "formats"))
# 将输出格式添加到输出渠道
fh.setFormatter(form)
sh.setFormatter(form)
return log
def create_log(self):
'''创建日志'''
# 创建日志对象
log = logging.getLogger('yuan')
# 设置日志收集等级
log.setLevel(conf.get('log', 'log_level'))
# 日志保存路径
log_dir = os.path.join(LOG_DIR, conf.get('log', 'log_filename'))
# 创建日志收集器输出渠道
fh_log = TimedRotatingFileHandler(filename=log_dir,
when='S',
interval=60,
backupCount=7,
encoding='utf-8')
# 设置日志输出等级
fh_log.setLevel(conf.get('log', 'sh_level'))
log.addHandler(fh_log)
# 设置日志输出格式
formats = '%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
format = logging.Formatter(formats)
fh_log.setFormatter(format)
return log
class LoginPage(BasePage):
#
url = conf.get('url', 'base_url') + conf.get("url", "login_url")
def __init__(self, driver):
super().__init__(driver)
# 打开登录页面
self.driver.get(self.url)
self.driver.implicitly_wait(15)
def login(self, user, pwd):
'''传入用户名和密码，然后进行登录'''
self.input_text(loc.mobile_loc, user, "登录_账号输入")
# 输入密码
self.input_text(loc.pwd_loc, pwd, "登录_密码输入")
# 点击登录
self.click_ele(loc.login_btn, "登录_点击登录按钮")
def get_error_info(self):
'''获取到失败的提示消息'''
return self.get_ele_text(loc.err_hint, '登录_获取到失败的提示消息（非弹框)')
def get_alert_error_info(self):
"""获取页面弹窗的错误提示信息"""
return self.get_ele_text(loc.err_alert, '登录_页面弹窗错误提示')
def page_refresh(self):
# 刷新页面，提高用例执行效率 操作selenium再次访问元页面
self.driver.get(url=self.url)
def cancle_rember_mobile(self):
# 取消记住手机号，方便多条用例执行
self.click_ele(loc.re_mobile, '登录_点击取消记住手机号')
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='通过')
class LoginPage(BasePage):
"""登陆页面"""
# 登陆的url地址
url = conf.get('env', 'base_url') + conf.get('url', 'login_url')
def __init__(self, driver):
super().__init__(driver)
self.driver.get(self.url)
self.driver.implicitly_wait(15)
def login(self, user, pwd):
"""输入账户密码点击登录"""
self.input_text(loc.mobile_loc, user, '登录_账户输入')
# 输入密码
self.input_text(loc.pwd_loc, pwd, '登录_密码输入')
# 点击登录
self.click_element(loc.login_loc, '登陆_点击元素')
def get_error_info(self):
"""获取登陆失败的提示信息"""
return self.get_element_text(loc.error_info, '登陆_失败提示信息')
def get_alert_error_info(self):
"""获取页面弹窗的错误信息"""
ele = self.wait_element_visibility(loc.alert_error_info, '登录_页面弹窗错误提示')
return ele.text
def page_refresh(self):
"""刷新页面"""
self.driver.get(url=self.url)
def click_re_mobile(self):
"""取消记住手机号"""
self.click_element(loc.re_mobile, "登录_点击取消记住手机号")
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 creat_logger():
"""
创建日志收集器
:return:logger
"""
# 创建一个日志收集器
logger = logging.getLogger("zkl")
# 设置日志等级
logger.setLevel(conf.get('log', 'level'))
# 设置输出渠道及输出等级
# 1、日志写入自定义的log文件
fh = logging.FileHandler(log_filepath, encoding='utf8')
fh.setLevel(conf.get('log', 'fh_level'))
logger.addHandler(fh)
# 日志标准输出stdout
sh = logging.StreamHandler()
sh.setLevel(conf.get('log', 'sh_level'))
logger.addHandler(sh)
# 创建一个输出格式
formats = '%(asctime)s --[%(filename)s-->line:%(lineno)d] - %(levelname)s:%(message)s'
form = logging.Formatter(formats)
# 设置各渠道日志输出格式
fh.setFormatter(form)
sh.setFormatter(form)
return logger
def test_audit(self, item):
# 第一步：准备用例数据
url = conf.get("env", "base_url") + item["url"]
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = self.admin_token
# 替换用例参数
item["data"] = replace_data(item["data"], TestAudit)
params = eval(item["data"])
# 请求方法
method = item["method"]
# 预期结果
expected = eval(item["expected"])
# 第二步：请求接口，获取实际返回的结果
response = requests.request(url=url, method=method, json=params, headers=headers)
res = response.json()
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if item["title"] == "审核通过":
TestAudit.pass_loan_id = params["loan_id"]
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
self.excel.write_excel(row=item['case_id'] + 1, column=8, value='未通过')
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
self.excel.write_excel(row=item['case_id'] + 1, column=8, value='通过')
def create_logger():
"""
创建日志收集器
:return: 日志收集器
"""
# 第一步：创建一个日志收集器
log = logging.getLogger("Addicated")
# 第二步：设置收集器收集的等级
log.setLevel(conf.get("log", "level"))
# 第三步：设置输出渠道以及输出渠道的等级
fh = logging.FileHandler(log_filepath, encoding="utf8")
fh.setLevel(conf.get("log", "fh_level"))
log.addHandler(fh)
sh = logging.StreamHandler()
sh.setLevel(conf.get("log", "sh_level"))
log.addHandler(sh)
# 创建一个输出格式对象
formats = '%(asctime)s -- [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
form = logging.Formatter(formats)
# 将输出格式添加到输出渠道
fh.setFormatter(form)
sh.setFormatter(form)
return log
def test_update(self, cas):
url = conf.get('env', 'url') + cas['url']
method = cas['method']
cas['data'] = replace_data(cas['data'])
data = eval(cas['data'])
headers = eval(conf.get('env', 'headers'))
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()
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
#判断数据库中是否更新昵称
if cas['check_sql']:
sql = replace_data(cas['check_sql'])
s = self.bb.find_one(sql)['reg_name']
self.assertEqual(data['reg_name'], s)
except AssertionError as e:
log.error('该用例{}报错'.format(cas['title']))
log.exception(e)
self.exce.write(row=row, column=8, value='不通过')
raise e
else:
log.info('该用例{}通过'.format(cas['title']))
self.exce.write(row=row, column=8, value='通过')
def test_audit(self, cas):
url = conf.get('env', 'url') + cas['url']
method = cas['method']
data = eval(replace_data(cas['data']))
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = getattr(EnvData, 'admin_token')
expected = eval(cas['expected'])
row = cas['case_id'] + 1
respones1 = request(url=url, method=method, json=data, headers=headers)
res1 = respones1.json()
if cas['title'] == '审核通过' and res1['msg'] == 'OK':
setattr(EnvData, 'pass_loan_id', str(data['loan_id']))
print('预期结果：', expected)
print('实际结果：', res1)
try:
self.assertEqual(expected['code'], res1['code'])
self.assertEqual(expected['msg'], res1['msg'])
#判断审核状态是否符合预期的结果
if cas['check_sql']:
sql = replace_data(cas['check_sql'])
status = self.bb.find_one(sql)['status']
self.assertEqual(expected['status'], status)
except AssertionError as e:
log.error('这条用例{}没有通过'.format(cas['title']))
log.exception(e)
self.exce.write(row=row, column=8, value='不通过')
raise e
else:
log.info('这条用例{}执行通过'.format(cas['title']))
self.exce.write(row=row, column=8, value='通过')
def setUpClass(cls):
# 前置条件1:请求搜索药品接口获取药品返回信息,设置为类属性
url1 = conf.get("env", "url") + "/Inquiry"
method1 = "post"
headers1 = eval(conf.get("env", "headers"))
data1 = {"QueryType": "getDrugList",
"Params": '{"page":1,"keyword":"' + conf.get("test_data", "drugs") + '","barcode":""}',
"UserGuid": login()}
res1 = (request(url=url1, method=method1, data=data1, headers=headers1, verify=False)).json()
# 提取药品编号和药品名称作为类属性
EnvData.drugs_id = jsonpath.jsonpath(res1, "$..GUID")[0]
EnvData.goodsname = jsonpath.jsonpath(res1, "$..GOODSNAME")[0]
# 前置条件2: 请求获取医生列表,获取医生ID和医生手机号,设置为类属性
url2 = conf.get("env", "url") + "/Inquiry"
method2 = "post"
headers2 = eval(conf.get("env", "headers"))
data2 = {"QueryType": "syncDoctorList", "Params": '{"keyword":""}', "UserGuid": login()}
res2 = (request(url=url2, method=method2, data=data2, headers=headers2, verify=False)).json()
# 提取医生接口返回值 医生编号,医生手机号
try:
EnvData.doctorId = jsonpath.jsonpath(res2, "$..GUID")[0]
EnvData.doctorPhone = jsonpath.jsonpath(res2, "$..PHONE")[0]
except Exception as e:
print("没有医生在线")
def test_login(self, item):
# 第一步：准备用例数据
# 接口地址
url = conf.get("env", "base_url") + item["url"]
# 请求头
headers = eval(conf.get("env", "headers"))
# 请求参数
item["data"] = replace_data(item["data"], TestLogin)
params = eval(item["data"])
# 预取结果
expected = eval(item["expected"])
# 请求方法
method = item["method"]
# 第二步：调用接口，获取实际结果
response = requests.request(method,
url=url,
json=params,
headers=headers)
res = response.json()
print("预期结果：", expected)
print("实际结果：", response.text)
# 第三步：断言
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
except AssertionError as e:
log.error("用例{}，执行未通过".format(item["title"]))
log.exception(e)
raise e
else:
log.info("用例{}，执行通过".format(item["title"]))
def email():
# 连接s mtp服务
smtp = smtplib.SMTP_SSL(host='smtp.qq.com', port=465)
# 登录
smtp.login(user=conf.get('smtp', 'user'),
password=conf.get('smtp', 'password'))
# 创建多组件套件
msg = MIMEMultipart()
msg['subject'] = '我给你的邮件'
msg['To'] = '*****@*****.**'
msg['From'] = '*****@*****.**'
# 获取报告内容
q = os.path.join(REPORTS_DIR, 'bur.html')
with open(q, 'rb') as f:
count = f.read()
# 创建一个邮件附件，将读取的内容加到附件
report = MIMEApplication(count)
#设置附件显示的名称
report.add_header('content-disposition',
'attachment',
filename='python.html')
msg.attach(report)
#构建一个邮件文本内容
text = MIMEText('嘿嘿嘿嘿嘿', _charset='utf8')
msg.attach(text)
# 发送邮件
smtp.send_message(msg,
from_addr='*****@*****.**',
to_addrs='*****@*****.**')
def create_log():
# 1、创建日志收集器
log = logging.getLogger('mylog')
# 设置日志收集等级
log.setLevel(conf.get('logging', 'level'))
# 2、创建日志输出渠道
# 创建控制台输出渠道
sh = logging.StreamHandler()
# 设置控制台的输出日志等级
sh.setLevel(conf.get('logging', 'sh_level'))
# 将控制台日志输出渠道与日志收集器进行绑定
log.addHandler(sh)
# 创建文件输出渠道
fh = TimedRotatingFileHandler(filename=os.path.join(LOG_DIR, conf.get('logging', 'log_name')),
when='d',
interval=1,
backupCount=7,
encoding='utf-8')
# 设置文件输出渠道的日志等级
fh.setLevel(conf.get('logging', 'fh_level'))
# 将文件日志输出渠道与日志收集器进行绑定
log.addHandler(fh)
# 3、设置日志输出格式
formatter = '%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
mat = logging.Formatter(formatter)
# 设置日志输出渠道的日志显示格式
fh.setFormatter(mat)
sh.setFormatter(mat)
# 4、返回日志收集器
return log
def setup_login(cls):
"""
普通用户登录（投资接口中的借款人）
:param cls: 测试用例类
:return:
"""
"""写该用例类执行之前的前置
登录，获取token，和用户id
"""
login_url = conf.get("env", "base_url") + "/member/login"
params = {
"mobile_phone": conf.get("test_data", "mobile"),
"pwd": conf.get("test_data", "pwd")
}
header = eval(conf.get("env", "headers"))
response = requests.request(url=login_url,
method="post",
json=params,
headers=header)
res = response.json()
# 提取token
token = jsonpath(res, "$..token")[0]
cls.token_value = token
cls.token = "Bearer" + " " + token
# 提取用户id
cls.member_id = jsonpath(res, "$..id")[0]
def setUpClass(cls):
# 前置条件1:请求搜索会员获取会员编号,设置为类属性
url = conf.get("env", "url") + "/Inquiry"
method = "post"
headers = eval(conf.get("env", "headers"))
data = {
"QueryType": "searchMember",
"Params": '{"SEARCH":"123456"}',
"UserGuid": login()
}
res = (request(url=url,
method=method,
data=data,
headers=headers,
verify=False)).json()
# 提取药品编号和药品名称作为类属性
EnvData.memberid = jsonpath.jsonpath(res, "$..会员编号")[0]
# 前置条件2:请求获取预约号设置为类属性
url1 = conf.get("env", "url") + "/Inquiry"
method1 = "post"
headers1 = eval(conf.get("env", "headers"))
data1 = {
"QueryType": "syncUserOrderCode",
"Params":
'{"ERPCODE":"","MEMBERID":"' + EnvData.memberid + '","STATE":0}',
"UserGuid": login()
}
res1 = (request(url=url1,
method=method1,
data=data1,
headers=headers1,
verify=False)).json()
# 提取药品编号和药品名称作为类属性
EnvData.code = jsonpath.jsonpath(res1, "$..CODE")[0]
def creat_log():
'''封装日志收集器'''
# 1.创建日志收集器，设置收集器等级
log_collector = logging.getLogger("caibaozi")
log_collector.setLevel(conf.get("log", "collect_level"))
# 2.创建输出到控制台的渠道，设置输出等级
sh = logging.StreamHandler()
sh.setLevel(conf.get("log", "sh_level"))
log_collector.addHandler(sh)
# 3.创建输出到日志文件的渠道，设置输出等级
fh = logging.FileHandler(filename=os.path.join(LOG_DIR, "mylog.log"),
mode="a",
encoding="utf8")
fh.setLevel(conf.get("log", "fh_level"))
log_collector.addHandler(fh)
# 4.设置日志输出格式
format_str = '%(asctime)s-[%(filename)s-->line:%(lineno)d]-%(levelname)s:%(message)s'
fm = logging.Formatter(format_str)
# 5.绑定输出格式到控制台，文件
sh.setFormatter(fm)
fh.setFormatter(fm)
return log_collector
def test_info(self, item):
# 请求接口
url = conf.get('env', 'base_url') + replace_data(item['url'], TestInfo)
# 请求方法
method = item['method']
# 请求头
headers = eval(conf.get('env', 'headers'))
headers['Authorization'] = self.token
# 预期结果
expected = eval(item['expected'])
# 请求接口获得实际结果
response = requests.request(method=method, url=url, headers=headers)
res = response.json()
print('预计结果：', expected)
print('实际结果：', res)
# 断言
try:
self.assertEqual(res['code'], expected['code'])
self.assertEqual(res['code'], expected['code'])
except AssertionError as e:
log.exception(e)
log.error('用例{}，执行未通过'.format(item['title']))
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='未通过')
raise e
else:
log.info('用例{}，执行通过'.format(item['title']))
self.excel.write_excel(row=item['case_id'] + 1,
column=8,
value='通过')
def create_logger():
"""创建日志收集器"""
# 1、创建一个收集器
log = logging.getLogger("lemon")
log.setLevel(conf.get("logging", 'level')) # 设置收集日志的等级
# 2、创建一个输出到文件的输出渠道(按时间轮转),
fh = TimedRotatingFileHandler(file_path,
when='d',
interval=1,
backupCount=7,
encoding="utf-8")
fh.setLevel(conf.get("logging", 'fh_level')) # 设置输出等级
log.addHandler(fh) # 添加到收集器中
# 3、创建一个输出到控制台的输出渠道
sh = logging.StreamHandler()
sh.setLevel(conf.get('logging', 'sh_level')) # 设置输出等级
log.addHandler(sh) # 添加到收集器中
# 4、设置日志输出格式
formatter = "%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s"
mate = logging.Formatter(formatter)
fh.setFormatter(mate)
sh.setFormatter(mate)
return log
def test_recharge(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(replace_data(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"].format(self.member_id)
sql = replace_data(case["check_sql"])
start_money = self.db.find_one(sql)["leave_amount"]
print("充值之前的金额：", start_money)
# 第二步， 发送请求，获取实际结果
response = 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)
sql = replace_data(case["check_sql"])
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"]:
recharge_money = decimal.Decimal(str(data["amount"]))
self.assertEqual(recharge_money, end_money - start_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.error("用例--{}--执行通过".format(case["title"]))
self.excel.write_data(row=row, column=8, value="通过")
