def test_api(self, case):
url = self.base_url + case['url']
data = case['data']
method = case['method']
expected = str(case['expected'])
if data.find('${login_phone}') != -1:
data = data.replace('${login_phone}',
getattr(GetData, 'login_phone'))
elif data.find('${recharge_phone}') != -1:
data = data.replace('${recharge_phone}',
getattr(GetData, 'recharge_phone'))
res = HttpRequest.http_request(url=url,
data=eval(data),
method=method,
cookie=getattr(GetData, 'COOKIE'))
if res.cookies:
setattr(GetData, 'COOKIE', res.cookies)
try:
self.assertEqual(expected, res.json()['code'])
self.result = '通过'
except Exception as e:
MyLog().info('执行用例出错：{0}'.format(e))
self.result = '不通过'
raise e
finally:
MyLog().debug('获取到的结果是：{}'.format(res.json()))
ReadExcel(data_path,
'recharge').write_data(case['case_id'] + 1, self.result)
def test_register(self, case):
logger.info('开始测试：{0}'.format(case.title))
#参数化方式一：使用动态值进行参数化
if case.data.find('register_mobile') > -1:
#self.mysql = do_mysql.DoMysql()
# #使用手机号最大号码+1获取登录手机号码
# sql = 'select max(mobilephone) from future.member;'
# max_phone = self.mysql.fetch_one(sql)[0]
# max_phone = int(max_phone)+1
# print("最大手机号码",max_phone)
# case.data=case.data.replace('register_mobile',str(max_phone))#替换参数值
#使用随机数生成电话号码
num_start = [
'134', '135', '136', '137', '138', '139', '150', '151', '152',
'158', '159', '157', '182', '187', '188', '147', '130', '131',
'132', '155', '156', '185', '186', '133', '153', '180', '189'
]
start = random.choice(num_start)
end = ''.join(random.sample(string.digits, 8))
random_phone = start + end
logger.debug('注册号码：{0}'.format(random_phone))
case.data = case.data.replace('register_mobile',
str(random_phone)) # 替换参数值
#self.mysql.close()#关闭数据库
# 数据库校验，注册之前查询member表用户个数
if case.sql is not None:
sql = case.sql
member = self.mysql.fetch_one(sql)
before = member['count(*)']
logger.debug('注册前用户数：{0}'.format(before))
def test_add(self, case):
logger.info('開始測試：{}'.format(case.title))
if case.data.find('project_name'):
date = time.strftime('%Y-%m-%d %H_%M_%S')
project_name = date + 'Project'
case.data = case.data.replace('project_name', project_name)
def test_register(self, case):
my_log.info('开始执行第{}条测试用例：{}'.format(case.case_id, case.title))
# 在请求之前 先判断是否需要执行SQL
if case.check_sql:
sql = eval(case.check_sql)['sql1'] # 转化为字典格式 方便后期操作多个SQL语句
sql_result = self.db.fetch_one(sql)
register_before = sql_result['count(id)'] # 拿到数据后，要保存数据
print(type(register_before)) # <class 'int'>
print('注册之前数据库的总数有：', register_before)
if case.data.find('register_mobile') > -1:
sql = 'select max(mobilephone) from future.member'
max_phone = self.db.fetch_one(sql) # 查询最大的手机号码
print(type(max_phone)) # <class 'dict'>
print('取到的值：', max_phone) # {'max(mobilephone)': '18999999999'}
max_phone = max_phone['max(mobilephone)']
print(type(max_phone)) # <class 'str'>
print('最大：', max_phone) #18999999999
max_phone = int(max_phone) - random.randint(
100, 10000) # 最大手机号+1（保证手机号在数据库中不存在）
print('最大的手机号码：', max_phone)
# replace()函数 是替换之后重新返回一个新的字符串，有返回值 需要变量去接收
case.data = case.data.replace('register_mobile',
str(max_phone)) # 替换参数值
def test_register(self, case):
if case.data.find("register_mobile") > -1:
sql = 'select max(mobilephone) from future.member'
#sql = 'select * from future.member where mobilephone = "15717481999"'
#max_phone = self.mysql.fetch_one(sql)[0] #查询最大手机号码 ，fetchone返回值为元祖
phone = self.mysql.fetch_one(sql)[0]
new_phone = int(phone) + 1
# if self.mysql.fetch_one(sql) != None:
# phone = self.mysql.fetch_one(sql)[3]
#
# new_phone = int(phone) + 1
#
# user = self.mysql.fetch_one('select * from future.member where mobilephone = "new_phone"')
# print("请求user:"******"new_phone"')
# #最大手机号码+1
# #max_phone = int(max_phone) + 1
# #new_phone = int(new_phone) + 1
# #print("最大手机号码：",max_phone)
print("新手机号码：", new_phone)
case.data = case.data.replace(
'register_mobile',
str(new_phone)) #替换参数值,replace替换新的字符串，重新返回一个新的字符串
def test_register(self, case):
logger.info('开始执行用例：{0}----------'.format(case.title))
if case.data.find('register_mobile') > -1: #判断参数化标识
sql = 'select max(mobilephone) from future.member'
max_phone = self.mysql.fetch_one_tuple(sql)[0]
#最大手机号码加1
max_phone = int(max_phone) + 1
case.data = case.data.replace('register_mobile', str(max_phone))
def test_register(self, case):
if case.data.find('register_mobile') > -1: #判断参数化的标识
sql = 'select max(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)[0] #查询最大手机号码
#最大手机号码+1
print('最大手机号码', max_phone)
#replace方法是替换之后返回一个新的字符串，所以需要case.data重新接收
case.data = case.data.replace('register_mobile', str(max_phone))
def test_sendmcode(self, case):
# 随机生成IP地址，并且反射到Context类的属性中，方便后面参数调用
if case.data.find('sendmcode_ip') != -1:
random_ip = '192.168.1' + ''.join(random.sample(
string.digits, 2)) + '.1' + ''.join(
random.sample(string.digits, 2))
case.data = case.data.replace('sendmcode_ip', random_ip)
def test_register(self, case):
if case.data.find("register_mobilephone") > -1:
res_data = self.mysql.fecth_one(
"select max(mobilephone) from future.member")
print(res_data)
data_2 = str(int(res_data[0]) + 1)
case.data = case.data.replace("register_mobilephone", data_2)
print(case.data)
def test_verfyauthcase(self, case):
logger.info("开始执行:{}".format(case.title))
logger.info("--------------------")
if case.data.find("user_name") > -1:
name = random_name()
case.data = case.data.replace("user_name", name)
logger.info(
case.data
) # {"uid":"#uid#","true_name":"周已相","cre_id":"card_number"}
def test_register(self, case):
if case.data.find('register_mobile') > -1:
sql = 'select mobilephone from future.member where mobilephone = "13037680161";'
min_phone = self.mysql.fetch_one(sql)[0] #查询最大手机号码
#最大手机号码+1
min_phone = int(min_phone) + 11
print('最大手机号码', min_phone)
#最大手机号码替换参数值
case.data = case.data.replace('register_mobile', str(min_phone))
def test_register(self, case):
if case.data.find('register_mobile') > -1: # 判断参数化标识
sql = 'select max(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)[0] #查询最大的手机号码
max_phone = int(max_phone) + 1
# replace替换之后重新赋值给一个新的字符串
case.data = case.data.replace('register_mobile',
str(max_phone)) #用最大手机号码替换参数值
print(case.data)
def test_register(self, case):
if case.data.find('register_mobile') > -1: #判断参数化的标识
sql = 'select max(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)[0] #查询最大手机号码
#最大手机号码+1
max_phone = int(max_phone) + 1
#replace 方法是替换之后重新返回一个新的字符串
case.data = case.data.replace('register_mobile',
str(max_phone)) #替换参数值
def test_register(self, case):
if case.data.find("register_mobile"):
sql = "select max(mobilephone) from future.member"
register_mobile = int(
self.mysql.fetchone(sql)["max(mobilephone)"]) + 100
case.data = case.data.replace("register_mobile",
str(register_mobile))
print(case.data)
def test_register(self, case):
if case.data.find(
'register_mobile') > -1: #如果find没找到这个'register_mobile'，就返回-1
sql = 'select min(mobilephone) from future.member'
min_phone = self.mysql.fetch_one(sql)[
0] #查询最大/最小手机号,fetch-one返回的是一个元祖
#最大手机号码+1，从字符串转成int+1
max_phone = int(min_phone) + 18
case.data = case.data.replace('register_mobile',
str(max_phone)) #替换参数值，字符串是不可变数组，
def test_register(self, case):
if case.data.find("register_mobile") > -1:
self.mysql.fetchone(self.readsql)
# sql="SELECT MAX(MobilePhone) FROM future.member"
max_phone = self.mysql.fetchone(self.readsql)[0] # 获取最大手机号码 str
max_phone = int(max_phone) - 203 # 最大号码转为int型 再加一
print("最大手机号：", max_phone)
# replace方法是特换之后重新返回一个新的字符串，所以需要使用case.data重新接收
case.data = case.data.replace(
"register_mobile", str(max_phone)) # 因为手机号为str 所以要转换数据类型
def test_register(self, case):
logger.debug("开始测试:{0}".format(case.title))
# 加入数据库的查询
# 如何将数据库中查询到的数据，更新到测试用例中呢？测试数据做参数化，作为标识
if case.data.find("register_mobile") > -1:
sql = 'select max(MobilePhone) phone from future.member'
result = self.do_mysql.fetch_one(sql)
max_phone = result["phone"] # 获取最大的手机号，str
max_phone = int(max_phone) + 1
# 使用字符串的replace方法，指定替换
case.data = case.data.replace("register_mobile", str(max_phone))
def test_register(self, case):
if case.data.find('register_mobile'):
print(case.data.find('register_mobile'))
sql = 'select MAX(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)['MAX(mobilephone)']
max_phone = int(max_phone) - randint(1000, 9999) #利用随机数生成随机注册号
print(max_phone)
case.data = case.data.replace('register_mobile',
str(max_phone)) # 替换手机号码
print(case.data, '这里可以查看一下')
def test_register(self, case):
if case.data.find('register_mobile') > -1: # 判断参数化的标识
sql = 'select min(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)[0] # 查询最大手机号码
# 最大手机号码+1
print(max_phone)
max_phone = int(max_phone) + 111111
print('最大手机号码', max_phone)
print(type(case.data))
# replace方法是特换之后重新返回一个新的字符串，所以需要使用case.data重新接收
case.data = case.data.replace('register_mobile', str(max_phone)) # 特换参数值
def test_register(self,case):
print(case.title)
if case.data.find('register_mobile') > -1:
sql='select max(mobilephone) from future.member'
max_phone=self.mysql.fetch_one(sql)[0] #查询最大手机号码
#最大手机号码加1
# max_phone=int(max_phone)+1 #因为库里最大是18999999999，所以这行被我注释
print('最大手机号码',max_phone)
#replace()方法是替换之后重新返回一个新的字符串，需要重新赋值给case.data
case.data=case.data.replace('register_mobile',str(max_phone)) #最大手机号码替换参数值
def test_register(self, case):
if case.data.find(
'register_mobile') > -1: #如果find没找到这个'register_mobile'，就返回-1
sql = 'select min(mobilephone) as phone from future.member'
min_phone = self.mysql.fetch_one(sql)[
'phone'] #查询最大/最小手机号,fetch-one返回的是一个元祖
#最大手机号码+1，从字符串转成int+1
max_phone = int(min_phone) + 45
case.data = case.data.replace('register_mobile',
str(max_phone)) #替换参数值，字符串是不可变数组，
# 会生成一个新的值，不能再原有的上面替换，所以要给一个case.data值接收
print(case.data)
def test_OrderDeposit(self, case):
#生成时间
createTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
beginTime = (datetime.datetime.now() +
datetime.timedelta(hours=1)).strftime("%Y-%m-%d %H:%M:%S")
endTime = (datetime.datetime.now() +
datetime.timedelta(hours=11)).strftime("%Y-%m-%d %H:%M:%S")
# 创建时间
if case.data.find('createTime') != -1:
setattr(context.Context, 'createTime', createTime)
case.data = case.data.replace('%createTime%', createTime)
def test_register(self, case):
logger.info("目前执行第{0}条测试用例，测试开始:{1}".format(case.case_id, case.title))
if case.data.find('register_mobile'):
sql = "select max(mobilephone) from future.member"
mobile = self.do_sql.fetch_one(sql)['max(mobilephone)']
mobile = int(mobile) + 1
logger.info("用来发送请求的手机号码是{0}".format(mobile))
# replace方法是特换之后重新返回一个新的字符串，所以需要使用case.data重新接收
case.data = case.data.replace('register_mobile',
str(mobile)) # 特换参数值
logger.info("替换后的case.data为{0}".format(case.data))
def test_register(self, case):
log.info("开始执行测试{}".format(case.case_title))
if case.data.find("normal_user") > -1:
sql = "SELECT max(mobilephone) FROM future.member WHERE mobilephone LIKE '1860735%'"
max_phone = self.db.fetch_one(sql)['max(mobilephone)']
print("mysql:", max_phone) #查询最大手机号码，返回的是元组，根据索引获取第一条数据
before_max_phone = int(
max_phone) + 1 #max_phone是str类型，转成int类型，最大手机号码+1（也可以最小手机号码-1）
log.debug("before_max_phone号码:{}".format(before_max_phone))
#字符串的替换
case.data = case.data.replace("normal_user", str(before_max_phone))
def test_register(self, case):
cases = DoExcel(contants.case_file, 'register').get_cases()
if case.data.find('register_mobile') > -1:
sql = 'SELECT MAX(mobilephone) FROM future.member'
max_phone = self.mysql.fetch_one(sql)[
0] # 查询最大手机号码,fetch_one()返回的是一个元组
# max_phone = int(max_phone) + 1
print(max_phone)
random_num = random.randint(100, 999)
phone = int(max_phone) - random_num # 用最大手机号减去一个随机数，生成一个新的手机号
case.data = case.data.replace('register_mobile', str(phone))
print(case)
def test_register(self, case):
#print(case.data.find('register_mobile'))
self.logger.info('开始测试：{0}'.format(case.title))
i = random.randint(20, 100)
if case.data.find('register_mobile') > -1:
sql = 'select max(mobilephone) from future.member'
max_phone = self.mysql.fetch_one(sql)[
'max(mobilephone)'] #查询最大手机号码
#最大手机号码-i
max_phone = int(max_phone) - i
print(max_phone)
#replace方法是转换之后重新返回一个新的字符串
case.data = case.data.replace('register_mobile', str(max_phone))
def test_register(self, case):
loggor.debug('开始测试:{}'.format(case.title))
# 字符串的查找与替换, 查询数据库操作
if case.data.find('register_mobile') > -1:
sql = 'SELECT MobilePhone FROM future.member where MobilePhone=13821774377'
# 查询手机号码，返回结果为字典
max_phone = self.mysql.fetch_one(sql)
max_phone = int(max_phone['MobilePhone']) + 1
# 运用replace 对参数进行替换
case.data = case.data.replace('register_mobile', str(max_phone))
print(case.data)
sql = 'SELECT count(*) as num FROM future.member'
# 请求前的注册总数
before = self.mysql.fetch_one(sql)
print(before)
class WxmallTest(unittest.TestCase):
excel = do_excel.DoExcel(config.get('case', 'case_file'), 'wxMall')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
logger.logger.info("开始商城管理相关接口")
cls.http_request = HTTPRequest2()
cls.mysql = do_mysql.DoMysql()
params = config.get('data', 'data')
resp = cls.http_request.request('POST',
'/user/login',
'json',
jsons=params)
# 将登陆的token传入header里面，后面接口调用
cls.headers = {
"content-type": "application/json",
"Connection": "keep-alive",
'token': resp.json()['data']['token']
}
@data(*cases)
def test_payment(self, case):
case.data = context.replace(case.data)
random_str = ''.join(random.sample(string.ascii_letters, 6))
if case.data.find('proper_name') != -1:
case.data = case.data.replace('proper_name', random_str.lower())
setattr(context.Context, 'proper_name', random_str.lower())
class CustomerTest(unittest.TestCase):
excel = do_excel.DoExcel(config.get('case', 'case_file'), 'customer')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
logger.logger.info("开始测试销售管理相关接口")
cls.http_request = HTTPRequest2()
cls.mysql = do_mysql.DoMysql()
params = config.get('data', 'data')
resp = cls.http_request.request('POST',
'/user/login',
'json',
jsons=params)
#将登陆的token传入header里面，后面接口调用
cls.headers = {
"content-type": "application/json",
"Connection": "keep-alive",
'token': resp.json()['data']['token']
}
@data(*cases)
def test_customer(self, case):
case.data = context.replace(case.data)
logger.logger.info("开始测试：{0},发送的请求是：{1},请求类型：{2}".format(
case.title, case.data, type(case.data)))
# 随机生成用户名，并且反射到Context类的属性中，方便后面参数调用
random_str = ''.join(random.sample(string.ascii_letters, 6))
if case.data.find('customer_name') != -1:
case.data = case.data.replace('customer_name', random_str.lower())
setattr(context.Context, 'customer_name', random_str)
class OrderDeposit(unittest.TestCase):
excel = do_excel.DoExcel(contans.case_data, '线下支付业务流程')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
cls.http_request = HTTPRequest()
@data(*cases)
def test_OrderDeposit(self, case):
#生成时间
createTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
beginTime = (datetime.datetime.now() +
datetime.timedelta(hours=1)).strftime("%Y-%m-%d %H:%M:%S")
endTime = (datetime.datetime.now() +
datetime.timedelta(hours=11)).strftime("%Y-%m-%d %H:%M:%S")
# 创建时间
if case.data.find('createTime') != -1:
setattr(context.Context, 'createTime', createTime)
case.data = case.data.replace('%createTime%', createTime)
# 发车时间
if case.data.find('beginTime') != -1:
setattr(context.Context, 'beginTime', beginTime)
case.data = case.data.replace('%beginTime%', beginTime)
