def to_param(cls, data):
# 未注册手机号的参数化
if re.search(cls.not_existed_tel_pattern, data):
do_mysql = HandleMysql()
data = re.sub(cls.not_existed_tel_pattern, do_mysql.create_not_existed_mobile(), data)
do_mysql.close()
# 不存在的用户id替换
if re.search(cls.not_existed_id_pattern, data):
do_mysql = HandleMysql()
sql = "SELECT id FROM member ORDER BY id DESC limit 0, 1;"
not_existed_id = do_mysql.run(sql).get('id') + 1 # 获取最 大的id加1
data = re.sub(cls.not_existed_id_pattern, str(not_existed_id), data)
do_mysql.close()
# 注册用户手机号的参数化
if re.search(cls.invest_user_tel_pattern, data):
invest_user_tel = cls.do_user_account.read('invest', 'mobile_phone')
data = re.sub(cls.invest_user_tel_pattern, invest_user_tel, data)
# 注册用户密码的参数化
if re.search(cls.invest_user_pwd_pattern, data):
invest_user_pwd = cls.do_user_account.read('invest', 'pwd')
data = re.sub(cls.invest_user_tel_pattern, invest_user_pwd, data)
# 参数化投资人的id
if re.search(cls.invest_user_id_pattern, data):
invest_user_id = cls.do_user_account.read('invest', 'id')
data = re.sub(cls.invest_user_id_pattern, str(invest_user_id), data)
# loan_id 替换
if re.search(cls.loan_id_pattern, data):
loan_id = getattr(cls, 'loan_id')
data = re.sub(cls.loan_id_pattern, str(loan_id), data)
return data
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 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):
# 创建session对象
cls.do_request = HandleRequest()
# 添加到配置文件并设置公共请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建mysql数据连接，用来做数据校验
cls.do_mysql = HandleMysql()
def get_phone_nums(cls, username, password='******', type=1):
hm = HandleMysql()
hr = HandleRequests()
url = hy.read_yaml('request', 'base_url') + hy.read_yaml(
'request', 'register_url')
phone = hm.no_exsit_phone_mysql()
hr.common_heads({
hy.read_yaml('request', 'request_head'):
hy.read_yaml('request', 'request_value')
})
datas = {
"mobile_phone": phone,
"pwd": password,
"type": type,
"reg_name": username
}
res = hr.send(url=url, data=datas)
if res.json()['code'] == 0:
id = res.json()['data']['id']
phone_data = {
username: {
"mobile_phone": phone,
"pwd": password,
"type": type,
"id": id,
"reg_name": username
}
}
hm.close()
hr.close()
return phone_data
def get_re(cls, data):
hm = HandleMysql()
phone = hm.get_right_phone()
if re.search(r'{no_exist_phone}', data):
result = re.sub(r'{no_exist_phone}', phone, data)
return result
return data
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 setUpClass(cls) -> None:
# 创建请求对象
cls.do_request = HandleRequest()
# 添加公共请求头
cls.do_request.add_headers(do_yaml.read("api", "version"))
#创建mysql对象
cls.do_mysql = HandleMysql()
def create_new_user(regname, pwd='123456'):
'''创建一个账户'''
handle_mysql = HandleMysql()
send_request = HttpRequest()
url = do_config.get_value('api', 'prefix_url') + '/member/register'
sql = 'select id from member where MobilePhone=%s;'
while True:
mobilephone = handle_mysql.create_not_existed_mobile()
data = {'mobilephone':mobilephone, 'pwd':pwd, 'regname':regname}
send_request.to_request(method='post',
url=url,
data=data)
result = handle_mysql.to_run(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 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 existed_tel_replace(cls, data):
handle_mysql = HandleMysql()
if re.search(cls.existed_tel_parttern, data):
exist_tel = handle_mysql.get_existed_mobile()
data = re.sub(cls.existed_tel_parttern, exist_tel, data)
handle_mysql.close()
return data
def not_existed_replace(cls, data):
"""
不存在的参数替换
:param data:待替换的字符串
:return:
"""
# 创建数据库连接对象
cls.do_mysql = HandleMysql()
# 替换不存在的手机号
if cls.not_existed_phone in data:
data = re.sub(cls.not_existed_phone, \
cls.do_mysql.create_not_existed_mobile(), data)
# 替换不存在的用户id
if cls.not_existed_user_id in data:
# 数据库中取出最大的id值加1
sql = "SELECT id FROM member ORDER BY id DESC LIMIT 0,1;"
max_id = cls.do_mysql.run_sql(sql)
data = re.sub(cls.not_existed_user_id, str(max_id['id'] + 1), data)
# 替换不存在的标id
if cls.not_existed_loan_id in data:
# 数据库中取出最大的标id值加1
sql = "SELECT id FROM loan ORDER BY id DESC LIMIT 0,1;"
max_id = cls.do_mysql.run_sql(sql)
data = re.sub(cls.not_existed_loan_id, str(max_id['id'] + 1), data)
cls.do_mysql.close()
return data
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 my_re(cls, datas):
hm = HandleMysql()
phone = hm.get_non_existent()
if re.search(r'{no_exist_phone}', datas):
result = re.sub(r'{no_exist_phone}', phone, datas)
return result
return datas
def create_new_user(regname, pwd='123456'):
handle_mysql = HandleMysql()
send_request = HttpRequests()
do_config = HandleConfig(CONFIGS_FILE_TESTCASE1)
url = do_config.get_value('requests', 'url_head') + '/member/register'
print(url)
sql = "select Id from member where MobilePhone = %s;"
while True:
mobilephone = handle_mysql.create_not_existed_mobile()
print(mobilephone)
print(pwd)
print(regname)
data = {"mobilephone": mobilephone, "pwd": pwd, "regname": regname}
#new_data = json.dumps(data)
res = send_request.to_request(method="post", url=url, data=data)
print(res.text)
result = handle_mysql.run_mysql(sql, (mobilephone, ))
print('ddddddd{}'.format(result))
#result为空，说明注册没成功，则执行for循环下一次，直到成功
if result:
user_id = result['Id']
break
user_dict = {
regname: {
"Id": user_id,
"regname": regname,
"mobilephone": mobilephone,
"pwd": pwd
}
}
return user_dict
handle_mysql.close()
def to_param(cls, data):
# 不存在的手机号替换
if re.search(cls.not_existed_tel_pattern, data):
do_mysql = HandleMysql()
data = re.sub(cls.not_existed_tel_pattern,
do_mysql.create_not_existed_mobile(), data)
do_mysql.close()
# 管理员手机号替换
if re.search(cls.admin_user_tel_pattern, data):
# do_user_account = HandleYaml(USER_ACCOUNTS_FILE_PATH)
invest_user_tel = cls.do_user_account.read('admin', 'mobile_phone')
data = re.sub(cls.admin_user_tel_pattern, invest_user_tel, data)
# 投资人密码替换
if re.search(cls.admin_user_pwd_pattern, data):
invest_user_pwd = cls.do_user_account.read('invest', 'pwd')
data = re.sub(cls.admin_user_pwd_pattern, invest_user_pwd, data)
#替换companyId
if re.search(cls.admin_companyId_pattern, data):
# invest_companyId = cls.do_user_account.read('invest', 'companyId')
# data = re.sub(cls.invest_companyId_pattern, invest_companyId, data)
invest_companyId = getattr(cls, 'companyId')
data = re.sub(cls.admin_companyId_pattern, str(invest_companyId),
data)
return data
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 setUpClass(cls):
cls.do_request = HandleRequest()
# 添加请求头
cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
# 创建数据库处理对象
cls.do_mysql = HandleMysql()
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 handle_para(cls, data):
hl = HandleYaml(PHONE_PATH)
hm = HandleMysql()
if re.search(r'{no_exist_phone}', data):
phone = hm.no_exsit_phone_mysql()
re_data = re.sub(r'{no_exist_phone}', phone, data)
HandleMysql().close()
return re_data
if re.search(r'{invest_phone}', data):
re_data = re.sub(r'{invest_phone}',
hl.read_yaml('investor', 'mobile_phone'), data)
return re_data
if re.search(r'{user_id_re}', data):
re_data = re.sub(r'{user_id_re}',
str(hl.read_yaml('investor', 'id')), data)
return re_data
if re.search(r'{member_id_re}', data):
re_data = re.sub(r'{member_id_re}',
str(hl.read_yaml('borrower', 'id')), data)
return re_data
if re.search(r'{borrow_phone}', data):
re_data = re.sub(r'{borrow_phone}',
hl.read_yaml('borrower', 'mobile_phone'), data)
return re_data
if re.search(r'{no_exist_num}', data):
re_data = re.sub(
r'{no_exist_num}',
str(
hm.get_mysql_result(hy.read_yaml('mysql', 'id_sql'))
['maxId'] + 1), data)
return re_data
if re.search(r'{admin_phone}', data):
re_data = re.sub(r'{admin_phone}',
hl.read_yaml('admin', 'mobile_phone'), data)
return re_data
if re.search(r'{load_id}', data):
re_data = re.sub(r'{load_id}', str(getattr(cls, 'program_id')),
data)
return re_data
if re.search(r'{user_id}', data):
my_data = re.sub(r'{user_id}', str(hl.read_yaml('investor', 'id')),
data)
re_data = re.sub(r'{loan_id_re}', str(getattr(cls, 'program_id')),
my_data)
return re_data
return data
def set_up():
hr = HandleRequests()
hm = HandleMysql()
hl = HandleYaml(PHONE_PATH)
hr.common_heads({hy.read_yaml('request', 'request_head'): hy.read_yaml('request', 'request_value')})
yield hr, hm, hl
hr.close()
hm.close()
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 setUpClass(cls) -> None: # setUpClass是unittest框架的方法，会被unittest框架自动调用
"""
在当前类中所有实例方法执行之前会被调用一次
重写父类的类方法
:return:
"""
cls.send_request = HandleRequest()
cls.handle_mysql = HandleMysql()
do_log.info("\n\n{:=^40s}".format("开始执行投资功能用例"))
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 test_product(self, case):
# 1. 参数化
new_data = Parameterize.to_param(case.data)
# 2. 拼接完整的url
if case.case_id == 4:
mysql = HandleMysql()
ss = mysql.run(do_yaml.read('mysql', 'select_product_id'))
new_url = do_yaml.read('api', 'prefix') + case.url + ss['id']
mysql.close()
def not_existed_tel_repalce(cls, data):
"""
data 是待替换的原始字符串 用if先判断，可以节省资源
"""
if re.search(cls.not_existed_tel_pattern, data):
handle_mysql = HandleMysql()
not_existed_tel = handle_mysql.create_not_existed_mobile()
data = re.sub(cls.not_existed_tel_pattern, not_existed_tel, data)
return data
handle_mysql.close()
def register_not_existed_replace(cls, data):
'''
不存在手机号进行参数化
'''
if re.search(cls.register__unregistered_mobile, data):
do_mysql = HandleMysql()
data = re.sub(cls.register__unregistered_mobile,
do_mysql.create_not_existed_mobile(), data)
do_mysql.close()
return data
def not_existed_tel_replace(cls, data):
'''
:param data:待替换的原始字符串
:return:
'''
handle_mysql = HandleMysql()
if re.search(cls.not_existed_tel_parttern, data):
not_exist_tel = handle_mysql.create_not_existed_mobile()
data = re.sub(cls.not_existed_tel_parttern, not_exist_tel, data)
handle_mysql.close()
return data
def exists_mobile_replace(cls, data):
"""
替换存在的手机号
:param data:
:return:
"""
if re.search(cls.exists_mobile_pattern, data):
mobile_phone = HandleMysql().get_exists_mobile()
data = re.sub(cls.exists_mobile_pattern, mobile_phone, data)
return data
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