def create_new_user(regname, pwd="Gl123456"):
"""
创建一个用户
:param pwd:
:param regname:
:return:
"""
handle_mysql = HandleMysql()
send_request = HandleRequest()
url = do_config("api", "url") + "/member/register"
sql = "SELECT Id FROM member WHERE MobilePhone=%s;"
while True:
mobilephone = handle_mysql.create_not_existed_tel()
data = {"mobilephone": mobilephone, "pwd": pwd, "regname": regname}
send_request(method="post", url=url, data=data)
result = handle_mysql(sql=sql, args=(mobilephone,))
if result:
user_id = result["Id"]
break
user_dict = {
regname: {
"Id": user_id,
"regname": regname,
"mobilephone": mobilephone,
"pwd": pwd
}
}
handle_mysql.close()
send_request.close()
return user_dict
def setUpClass(cls):
# 构造请求参数
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.get_data(
"api", "api_version")) # 添加请求头到公共请求头
do_log.info("开始执行用例")
def setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建数据库处理对象
cls.do_mysql = HandleMysql()
def setUpClass(cls):
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
cls.do_mysql = HandleMysql()
# cls.do_mysql.create_not_existed_mobile()
do_log.info("开始执行用例")
def setUpClass(cls) -> None:
# 创建请求对象
cls.do_request = HandleRequest()
# 添加公共请求头
cls.do_request.add_headers(do_yaml.read("api", "version"))
#创建mysql对象
cls.do_mysql = HandleMysql()
def setUpClass(cls):
# 创建session对象
cls.do_request = HandleRequest()
# 添加到配置文件并设置公共请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建mysql数据连接，用来做数据校验
cls.do_mysql = HandleMysql()
class TestCaseLogin(unittest.TestCase):
do_request = HandleRequest()
do_config = HandleConfig(CONFIG_REQUEST)
do_excel = HandleExcel(DATA_CASES, 'login')
cases = do_excel.get_cases()
do_log = HandleLog
do_re = Handle_Re
pass_result = do_config.get_value('result', 'pass_result')
fail_result = do_config.get_value('result', 'fail_result')
@classmethod
def setUpClass(cls):
cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8')
cls.one_file.write('{:=^40s}\n'.format('开始执行登录接口用例'))
@classmethod
def tearDownClass(cls):
cls.one_file.write('{:=^40s}\n\n'.format('登录接口用例执行结束'))
cls.one_file.close()
@data(*cases)
def test_login(self, one_case):
# 拼接完整的url
new_url = self.do_config.get_value('url', 'head_url') + one_case['url']
# 获取请求方式
method = one_case['method']
# 获取input_data数据
# input_data = one_case['input_data']
# 对excel的input_data数据进行参数化
new_data = self.do_re.login_parameterization(one_case['input_data'])
# 发送请求接收请求后的结果
result_real = self.do_request.send_request(url=new_url,
data=eval(new_data),
method=method).text
try:
self.assertIn(one_case['expected'], result_real, msg='登录接口请求成功')
self.one_file.write('{},执行的结果为:{}\n'.format(
one_case['title'], self.pass_result))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.pass_result)
except AssertionError as err:
self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format(
one_case['title'], self.fail_result, err))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.fail_result)
raise err
self.do_request.close_request()
def setUpClass(cls): # setUpClass是unittest框架的方法，会被unittest框架自动调用
"""
在当前类中所有实例方法执行之前会被调用一次
重写父类的类方法
:return:
"""
cls.send_request = HandleRequest()
do_log.info("\n\n{:=^40s}".format("开始执行加标功能用例"))
class TestRegister(unittest.TestCase):
handleExcel = HandleExcel(DATA_CASES, 'register')
cases = handleExcel.get_cases()
do_config = HandleConfig(CONFIG_REQUEST)
head_url = do_config.get_value('url', 'head_url')
do_request = HandleRequest()
# 用例执行通过信息
pass_result = do_config.get_value('result', 'pass_result')
# 用例执行不通过信息
fail_result = do_config.get_value('result', 'fail_result')
do_re = Handle_Re()
@classmethod
def setUpClass(cls):
cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8')
cls.one_file.write('{:=^40s}\n'.format('开始执行注册接口用例'))
@classmethod
def tearDownClass(cls):
cls.one_file.write('{:=^40s}\n\n'.format('注册接口用例执行结束'))
cls.one_file.close()
@data(*cases)
def test_register(self, one_case):
# 注册接口的url
new_url = self.head_url + one_case['url']
# 对用例中的数据进行参数化
new_data = self.do_re.register_parameterization(one_case['input_data'])
method = one_case['method']
# 发送注册接口的请求
result_real = self.do_request.send_request(url=new_url,
data=eval(new_data),
method=method).text
try:
self.assertIn(one_case['expected'], result_real, msg='注册接口请求成功')
self.one_file.write('{},执行的结果为:{}\n'.format(
one_case['title'], self.pass_result))
self.handleExcel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.pass_result)
except AssertionError as err:
self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format(
one_case['title'], self.fail_result, err))
self.handleExcel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_real,
result=self.fail_result)
raise err
self.do_request.close_request()
def get_phone(cls, username, password='******', type=1):
hr = HandleRequest()
hm = HandleMysql()
base_url = hy.read_yaml('api', 'load')
register_url = hy.read_yaml('api', 'register')
all_url = ''.join((base_url, register_url))
while True:
phone = hm.get_non_existent()
data = {
"mobile_phone": phone,
"pwd": password,
"type": type,
"reg_name": username
}
hr.common_head(hy.read_yaml('api', 'header'))
result = hr.send(url=all_url, data=data)
if result.json()['code'] == 0 and result.json()['msg'] == 'OK':
break
user_id = hm.get_mysql_result(sql=hy.read_yaml('mysql', 'user_id'),
args=phone)
result_data = {
username: {
"mobilephone": phone,
"pwd": password,
"user_id": user_id[0]['id'],
"reg_name": username
}
}
hr.close()
hm.close()
return result_data
def get_phone(cls, user, password="******", type_num=1):
hr = HandleRequest()
hm = HandleMysql()
hr.common_head({'X-Lemonban-Media-Type': 'lemonban.v2'})
base_url = hy.read_yaml('api', 'load')
register_url = hy.read_yaml('api', 'register')
all_url = ''.join((base_url, register_url))
while True:
# 获取在数据库中不存在的电话号码
phone = hm.get_right_phone()
data = {
"mobile_phone": phone,
"pwd": password,
"type": type_num,
"reg_name": user
}
result = hr.send(url=all_url, data=data)
if result.json()['code'] == 0 and result.json()["msg"] == "OK":
break
my_result = hm.get_mysql_result(hy.read_yaml('mysql', 'user_id'),
args=phone)
user_id = my_result[0]['id']
result_data = {
user: {
"user_phone": phone,
"pwd": password,
"user_id": user_id,
"reg_name": user
}
}
hm.close()
hr.close()
return result_data
def generate_phone(cls, reg_name, pwd='12345678', reg_type=1):
hr = HandleRequest()
hm = HandleMysql()
phone = hm.get_no_exist_phone()
header = hy.read_yaml('request', 'header')
hr.common_head(header)
data = {
"mobile_phone": phone,
"pwd": pwd,
'type': reg_type,
'reg_name': reg_name
}
value_result = hr.send(url=hy.read_yaml('register', 'url'), data=data)
if value_result.json()['code'] == 0:
result_phone = value_result.json()['data']['mobile_phone']
user_id = value_result.json()['data']['id']
person_result = {
reg_name: {
"mobile_phone": result_phone,
'pwd': pwd,
"type": reg_type,
"id": user_id,
"reg_name": reg_name
}
}
hr.close()
hm.close()
return person_result
def setUpClass(cls):
# 构造请求参数
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.get_data(
"api", "api_version")) # 添加请求头到公共请求头
cls.do_mysql = HandleMysql() # 创建HandleMysql对象
# cls.do_mysql.create_not_existed_mobile()
do_log.info("开始执行用例")
def create_new_user(reg_name, pwd='12345678', type=1):
"""
创建一个新用户
:param reg_name:
:param pwd:
:param type:
:return:
"""
# 创建session会话对象，用来发起请求
do_request = HandleRequest()
# 创建mysql对象
do_mysql = HandleMysql()
# 添加公共请求头
do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 注册请求的url
register_url = do_yaml.read_yaml('api', 'prefix') + '/member/register'
while True:
# 随机生成一个未注册的手机号
mobile_phone = do_mysql.create_not_exsited_mobile()
# 创建一个请求体参数
data = {
'mobile_phone': mobile_phone,
'pwd': pwd,
'type': type,
'reg_name': reg_name
}
# 调用注册接口，发起请求
do_request.send(register_url, data=data)
# 查询数据库用户ID的sql，同时进行了数据校验
sql = do_yaml.read_yaml('mysql', 'select_user_id_sql')
# 查询数据库，获取用户ID
result = do_mysql.run(sql, args=[mobile_phone], is_more=False)
# 判断是否存在，如果result为None，则用户不存在，if语句为真，用户创建成功，跳出循环
if result:
user_id = result['id']
break
# 构建用户信息为嵌套字典的字典
user_info = {
reg_name: {
'user_id': user_id,
'mobile_phone': mobile_phone,
'pwd': pwd,
'reg_name': reg_name}
}
# 关闭mysql对象
do_mysql.close()
# 关闭session会话对象
do_request.close()
return user_info
def setUpClass(cls):
# 创建HandleRequest对象
cls.do_request = HandleRequest()
# 获取url版本请求头数据并添加至请求头中
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 创建HandleMysql对象
cls.do_mysql = HandleMysql()
# 创建一个不存在的用户id，并加入到全局数据池中
setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id())
do_log.info("开始执行用例")
def set_up():
hr = HandleRequest()
hm = HandleMysql()
hr.common_head(hy.read_yaml('api', 'header'))
yield hr, hm, hy, hl
hr.close()
hm.close()
def create_new_user(regname, pwd='123456'):
'''
新建用户的封装类
'''
do_config = HandleConfig(CONFIG_REQUEST)
do_request = HandleRequest()
do_mysql = HandleMysql()
register_url = do_config.get_value('url', 'register_url')
sql = "SELECT Id FROM member WHERE MobilePhone = %s"
while True:
mobile = do_mysql.create_not_existed_mobile()
data = {"regname": regname, "mobilephone": mobile, "pwd": pwd}
do_request.send_request(url=register_url, data=data, method='post')
result = do_mysql.do_execute(sql, args=(mobile, ))
if result:
user_id = result['Id']
break
user_dict = {
regname: {
"user_id": user_id,
"mobile": mobile,
"pwd": pwd,
"regname": regname
}
}
do_mysql.close()
do_request.close_request()
return user_dict
def set_up():
hr = HandleRequest()
hm = HandleMysql()
hl = HandleYaml(PERSONPHONE_PATH)
hr.common_head(hy.read_yaml('request', 'header'))
yield hr, hm, hl
hr.close()
hm.close()
def create_new_user(reg_name, pwd="aaa123", user_type=1):
"""
创建一个用户
:param reg_name: 用户名
:param pwd: 密码
:param user_type: 用户类型
:return: 存储一个用户信息, 嵌套字典的字典(以用户名为key, 以用户信息所在字典为value)
"""
# 建立连接
do_mysql = HandleMysql()
do_request = HandleRequest()
# 添加公共请求头
do_request.add_headers(do_yaml.read('api', 'version'))
url = do_yaml.read('api', 'prefix') + '/member/register'
sql = do_yaml.read('mysql', 'select_userid_sql')
while True:
mobile_phone = do_mysql.create_not_existed_mobile()
data = {
"mobile_phone": mobile_phone,
"pwd": pwd,
"reg_name": reg_name,
"type": user_type
}
# 先注册接口发起请求
do_request.send(url, data=data)
# 查询数据库, 获取用户id
result = do_mysql.run(sql=sql, args=(mobile_phone, ))
if result:
user_id = result["id"]
break
# 构造用户信息字典
user_dict = {
reg_name: {
"id": user_id,
"reg_name": reg_name,
"mobile_phone": mobile_phone,
"pwd": pwd
}
}
# 关闭连接
do_mysql.close()
do_request.close()
return user_dict
def user_init(cls):
# 获取请求头
headers = {"X-Lemonban-Media-Type": "lemonban.v2"}
# 创建请求对象
do_request = HandleRequest()
# 添加请求头
do_request.add_headers(headers)
# url
url = 'http://api.lemonban.com/futureloan/member/register'
# 创建初始三个用户，如果已经创建过则不用再创
user = [{
'mobile_phone': '',
'pwd': '12345678',
'type': 0,
'reg_name': '管理员'
}, {
'mobile_phone': '',
'pwd': '12345678',
'type': 1,
'reg_name': '借款人'
}, {
'mobile_phone': '',
'pwd': '12345678',
'type': 1,
'reg_name': '投资人'
}]
do_yaml = HandleYaml(USER_ACCOUNTS_FILE_DIR)
number = HandleMysql()
new_user = {}
for i in user:
i["mobile_phone"] = number.create_not_existed_mobile()
# 发起请求
res = do_request.send(url=url, data=i).json()
# 获取用户id
new_user['{}'.format(i['reg_name'])] = res['data']
new_user['{}'.format(i['reg_name'])]['pwd'] = i['pwd']
# 写入配置文件
do_yaml.write_yaml(USER_ACCOUNTS_FILE_DIR, new_user)
# 关闭请求
do_request.close()
# 关闭数据库连接
number.close()
def create_user(reg_name, password=12345678, type=1):
"""
创建用户并将用户信息，添加至全局数据池中
:param reg_name: 用户昵称
:param password: 用户密码，默认为12345678
:param type: 用户类型，默认为1，普通用户
:return:
"""
do_request = HandleRequest()
do_mysql = HandleMysql()
# 获取未注册手机号
mobile_phone = do_mysql.create_not_existed_mobile()
# 构造请求参数
param = {
"mobile_phone": mobile_phone,
"pwd": password,
"reg_name": reg_name,
"type": type
}
# 构造请求url路径
url = "http://api.lemonban.com/futureloan/member/register"
# 获取api头信息
do_request.add_headers(do_yaml.get_data("api", "api_version"))
# 进行注册
res = do_request.send("POST", url, json=param)
# sql = do_yaml.get_data("mysql", "select_user_sql")
# do_mysql.get_values(sql, )
# 从响应报文中获取用户id
user_id = res.json()["data"]["id"]
# 关闭相关连接
do_request.close()
do_mysql.close()
# 将用户信息添加至全局数据池中
setattr(GlobalData, "${" + reg_name + "_user_tel}", mobile_phone)
setattr(GlobalData, "${" + reg_name + "_user_pwd}", password)
setattr(GlobalData, "${" + reg_name + "_user_id}", user_id)
def create_new_user(regname, pwd="123456"):
"""
生成一个用户
:param regname:
:param pwd:
:return:
"""
handle_mysql = HandleMysql()
handle_request = HandleRequest()
url = cf.get_value("api", "prefix_url") + "/member/register"
sql = "select Id from member where mobilephone=%s;"
while True:
mobile = handle_mysql.get_not_exists_mobile()
data = {"mobilephone": mobile, "pwd": pwd, "regname": regname}
handle_request.send_request("post", url, data)
ret = handle_mysql.select(sql, args=(mobile, ))
if ret:
user_id = ret["Id"]
break
user_dict = {
regname: {
"Id": user_id,
"regname": regname,
"mobilephone": mobile,
"pwd": pwd
}
}
handle_mysql.close()
handle_request.close()
return user_dict
def setUpClass(cls) -> None:
cls.request = HandleRequest()
logger.debug("\n{:=^40s}".format("开始执行测试"))
def setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
class TestInvest(unittest.TestCase):
do_re = Handle_Re()
do_request = HandleRequest()
do_config = HandleConfig(CONFIG_REQUEST)
# 初始化HandleExcel对象
do_excel = HandleExcel(sheetname='invest')
# 获取所有的用例
cases = do_excel.get_cases()
pass_result = do_config.get_value('result', 'pass_result')
fail_result = do_config.get_value('result', 'fail_result')
@classmethod
def setUpClass(cls):
cls.do_mysql = HandleMysql()
cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8')
cls.one_file.write('{:=^40s}\n'.format('开始执行投资接口用例'))
@classmethod
def tearDownClass(cls):
cls.do_mysql.close()
cls.one_file.write('{:=^40s}\n\n'.format('投资接口用例执行结束'))
cls.one_file.close()
@data(*cases)
# 对所有用例进行拆包
def test_invest(self, one_case):
# 获得单个的用例,获取单个用例的请求数据
# data = one_case['input_data']
# 对请求数据进行参数化,获取到参数化后的数据
new_data = self.do_re.invest_parameterization(one_case['input_data'])
# 获取请求的url地址
new_url = self.do_config.get_value('url', 'head_url') + one_case['url']
# 获取接口请求方式
method = one_case['method']
# 对接口发送请求,获取请求后的返回数据
result_data = self.do_request.send_request(url=new_url,
data=eval(new_data),
method=method).text
if "加标成功" in result_data:
check_sql = one_case['check_sql']
if check_sql:
# 对sql语句进行参数化
check_sql = self.do_re.invest_parameterization(check_sql)
# 获取到执行后的sql语句后的内容
result_sql = self.do_mysql.do_execute(check_sql)
# loan_id = result_sql['Id']
# loan_id = result_data.get('Id')
# Handle_Re.loan_id = result_data['Id']
# 第一个参数:实例对象,则会为该实例对象创建实例属性
# 第一个参数为类,则会创建类属性
# 第二个参数为属性名
# 第三个参数为具体的值
setattr(Handle_Re, "loan_id", result_sql.get('Id'))
# 获取接口请求成功的标识
expected = one_case['expected']
try:
self.assertIn(expected, result_data, msg='投资接口请求成功')
self.one_file.write('{}执行的结果为:{}\n'.format(one_case['title'],
self.pass_result))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_data,
result=self.pass_result)
except AssertionError as err:
self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format(
one_case['title'], self.fail_result, err))
self.do_excel.write_cell(row=one_case['case_id'] + 1,
column=7,
actual=result_data,
result=self.fail_result)
raise err
self.do_request.close_request()
def setUpClass(cls) -> None:
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.read("api", "version"))
def setUpClass(cls):
cls.do_request = HandleRequest() # 创建HandleRequest对象
cls.do_request.add_headers(do_yaml.read('api',
'version')) # 添加公共的请求头, url版本号
def setUpClass(cls):
# 3、构造请求参数
cls.do_request = HandleRequest()
cls.do_request.add_headers(do_yaml.get_data("api", "api_version"))
do_log.info("开始执行用例")
def setUpClass(cls):
cls.one_session = HandleRequest()
do_log.info("{:=^40s}".format("用例开始执行"))
def setUpClass(cls) -> None: #所有用例执行前会被调用一次
# 创建请求对象
cls.do_request = HandleRequest()
# 添加公共请求头
cls.do_request.add_headers(do_yaml.read("api", "version"))
