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 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 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 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 create_new_user(reg_name, pwd="12345678", user_type=1):
'''
创建用户
reg_name:用户昵称
pwd:密码
user_type:用户类型
返回一个用户信息，嵌套字典的字典，用户昵称为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(
'api', 'select_user_id') # 虽然响应报文中会返回用户ID，但是从数据库中取出，进一步数据校验了注册接口
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: # 如果查询结果不为空，则获取id
user_id = result['id']
break
# 构造用户信息字典
user_dict = {
reg_name: {
"id": user_id,
"mobile_phone": mobile_phone,
"pwd": pwd,
"reg_name": reg_name,
}
}
# 关闭连接
do_request.close()
do_mysql.close()
return user_dict
def not_existed_replace(cls, data):
do_mysql = HandleMysql()
# 不存在手机号的参数化
if cls.not_existed_tel_pattern in data: # 使用成员运算
data = re.sub(cls.not_existed_tel_pattern, do_mysql.create_not_existed_mobile(), data)
# 不存在的用户id替换
if re.search(cls.not_existed_id_pattern, data):
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)
# 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)
do_mysql.close()
return data
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.existed_tel_pattern, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.existed_tel_pattern,
cls.doyaml.read("investor", "mobile_phone"), data)
if re.search(cls.existed_tel_pattern_pwd, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.existed_tel_pattern_pwd,
cls.doyaml.read("investor", "pwd"), data)
if re.search(cls.error_user_pwd, data):
do_mysql = HandleMysql()
data = re.sub(cls.error_user_pwd,
do_mysql.create_not_existed_mobile(), data)
do_mysql.close()
if re.search(cls.invest_user_id, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.invest_user_id,
str(cls.doyaml.read("investor", "id")), data)
if re.search(cls.invest_user_tel, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.invest_user_tel,
cls.doyaml.read("investor", "mobile_phone"), data)
if re.search(cls.invest_user_pwd, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.invest_user_pwd,
cls.doyaml.read("investor", "pwd"), data)
if re.search(cls.not_existed_id, data):
do_mysql = HandleMysql()
sql = "select max(id) from member;"
max_id = do_mysql.run(sql)
data = re.sub(cls.not_existed_id, str(max_id["max(id)"] + 1), data)
do_mysql.close()
if re.search(cls.borrow_user_id, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.borrow_user_id,
str(cls.doyaml.read("borrower", "id")), data)
if re.search(cls.borrow_user_tel, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.borrow_user_tel,
cls.doyaml.read("borrower", "mobile_phone"), data)
if re.search(cls.borrow_user_pwd, data):
# doyaml = HandleYaml(CONFIGS_USER_FILE_PATH)
data = re.sub(cls.borrow_user_pwd,
cls.doyaml.read("borrower", "pwd"), data)
if re.search(cls.admin_user_tel, data):
data = re.sub(cls.admin_user_tel,
cls.doyaml.read("admin", "mobile_phone"), data)
if re.search(cls.admin_user_pwd, data):
data = re.sub(cls.admin_user_pwd, cls.doyaml.read("admin", "pwd"),
data)
if re.search(cls.loan_id_pattern, data):
# loan_id = getattr(Parameterize ,"loan_id")
loan_id = getattr(cls, "loan_id")
data = re.sub(cls.loan_id_pattern, str(loan_id), data)
if re.search(cls.not_existed_loan_id, data):
loan_id = getattr(cls, "loan_id")
data = re.sub(cls.not_existed_loan_id, str(loan_id + 1), data)
return data
def to_parameter(cls, data):
# 使用正则进行匹配得到包含未注册手机号的data
if re.search(cls.not_existed_tel_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
# 匹配得到含有未注册手机号的data
data = re.sub(cls.not_existed_tel_pattern,
do_mysql.create_not_exsited_mobile(), data)
# 关闭数据库游标对象、连接
do_mysql.close()
# 已存在的手机号:投资人手机号
if re.search(cls.existed_tel_pattern, data):
# 匹配得到含有已存在的手机号的data
data = re.sub(
cls.existed_tel_pattern,
cls.do_yaml_user.read_yaml('investor', 'mobile_phone'), data)
# 已存在手机号的密码：投资人密码
if re.search(cls.existed_pwd_pattern, data):
# 匹配得到含有已存在手机号的密码的data
data = re.sub(cls.existed_pwd_pattern,
cls.do_yaml_user.read_yaml('investor', 'pwd'), data)
# 会员ID：投资人ID
if re.search(cls.existed_investor_id_pattern, data):
# 匹配得到含有投资人会员ID的data
data = re.sub(
cls.existed_investor_id_pattern,
str(cls.do_yaml_user.read_yaml('investor', 'user_id')), data)
# 不存在的投资人ID
if re.search(cls.not_existed_id_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
# 配置文件中获取sql
# 这里也可以不把sql语句写入配置文件，直接将sql语句写在下面
sql = do_yaml.read_yaml('mysql', 'select_user_max_id_sql')
# 运行sql，得到一个字典
res_max = do_mysql.run(sql, is_more=False)
# 获取字典的值，转换为字符串，将原data进行参数化
data = re.sub(cls.not_existed_id_pattern,
str(res_max.get('max(id)') + 1), data)
# 关闭数据库游标对象、连接
do_mysql.close()
# 借款人ID
# 正则匹配：查找
if re.search(cls.existed_borrower_id_pattern, data):
data = re.sub(
cls.existed_borrower_id_pattern,
str(cls.do_yaml_user.read_yaml('borrower', 'user_id')), data)
# 借款人电话
if re.search(cls.existed_borrower_tel_pattern, data):
data = re.sub(
cls.existed_borrower_tel_pattern,
cls.do_yaml_user.read_yaml('borrower', 'mobile_phone'), data)
# 借款人密码
if re.search(cls.existed_borrower_pwd_pattern, data):
data = re.sub(cls.existed_borrower_pwd_pattern,
cls.do_yaml_user.read_yaml('borrower', 'pwd'), data)
# 管理员电话
if re.search(cls.existed_admin_tel_pattern, data):
data = re.sub(cls.existed_admin_tel_pattern,
cls.do_yaml_user.read_yaml('admin', 'mobile_phone'),
data)
# 管理员密码
if re.search(cls.existed_admin_pwd_pattern, data):
data = re.sub(cls.existed_admin_pwd_pattern,
cls.do_yaml_user.read_yaml('admin', 'pwd'), data)
# loan_id
if re.search(cls.loan_id_pattern, data):
loan_id = getattr(Parameterize, 'loan_id')
data = re.sub(cls.loan_id_pattern, str(loan_id), data)
# 不存在的loan_id
if re.search(cls.not_existed_loan_id_pattern, data):
# 创建数据库连接及游标对象
do_mysql = HandleMysql()
sql = "select id from loan order by id desc limit 0,1;"
# 运行sql，得到一个字典
res_max = do_mysql.run(sql, is_more=False)
# 获取字典的值，转换为字符串，将原data进行参数化
data = re.sub(cls.not_existed_loan_id_pattern,
str(res_max.get('id') + 1), data)
# 关闭数据库游标对象、连接
do_mysql.close()
return data
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.invest_user_tel_pattern, data):
# do_user_account = HandleYaml(USER_ACCOUNTS_FILE_PATH)
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_pwd_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')
# 投资人id为int类型, 要转化为str类型
data = re.sub(cls.invest_user_id_pattern, str(invest_user_id),
data)
# 不存在的用户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()
# 借款人id替换
if re.search(cls.borrow_user_id_pattern, data):
borrow_user_id = cls.do_user_account.read("borrow",
"id") # 获取已经注册的借款人用户id
data = re.sub(cls.borrow_user_id_pattern, str(borrow_user_id),
data)
# 借款人手机号替换
if re.search(cls.borrow_user_tel_pattern, data):
borrow_user_mobile = cls.do_user_account.read(
"borrow", "mobile_phone") # 获取已经注册的借款人手机号
data = re.sub(cls.borrow_user_tel_pattern, borrow_user_mobile,
data)
# 借款人密码替换
if re.search(cls.borrow_user_pwd_pattern, data):
borrow_user_pwd = cls.do_user_account.read("borrow",
"pwd") # 获取已经注册的借款人密码
data = re.sub(cls.borrow_user_pwd_pattern, borrow_user_pwd, data)
# load_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
