def test_cases(self, case):
global TestResult #全局变量
# global COOKIES#声明是一个全局变量
# 1:读取到测试数据
# 2:执行测试:遍历--根据Key取值
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# 发起测试
my_log.info('------正在测试{}模里面第{}条测试用例：{}'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(method,
url,
param,
cookies=getattr(GetData, 'COOKIE'))
#加一个判断
if resp.cookies: #判断请求的cookies是否为空 不为空其实就是为True
setattr(GetData, 'COOKIE', resp.cookies) #我们可以更新COOKIES这个全局变量的值
try:
self.assertEqual(eval(case['ExpectedResult']),
resp.json()) #http发送请求拿到的实际返回结果
TestResult = 'Pass'
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求出错了，错误是：{}'.format(str(e)))
raise e #处理完异常之后 不要留在家里 要抛出去
finally:
#写回结果
self.t.write_back(case['CaseId'] + 1, 8, resp.text) #请注意这里
self.t.write_back(case['CaseId'] + 1, 9, TestResult)
my_log.info('实际结果为：{}'.format(resp.json())) #http发送请求拿到的实际返回值
def test_case(self, case):
global TestResult
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# 发起测试
my_log.info('-----正在测试{}模块第{}条用例：{}'.format(case['Module'],
case['CaseId'],
case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(
method, url, param,
cookies=COOKIES) #http_request模块已经做了异常处理，所以在这里不用再做
try:
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'pass'
except AssertionError as e:
TestResult = 'Failed'
my_log.error('请求测试用例出错，错误是{}'.format(e))
raise e #处理完异常之后要抛出去 raise
finally:
#写回测试结果
self.t.write_back(case['CaseId'] + 1, 9, resp.text)
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果:{}'.format(resp.json())) # http发送请求拿到的实际返回值
my_log.info('期望结果：{}'.format(case['ExpectedResult']))
def test_cases(self,case):
global TestResult#全局变量
global COOKIES#声明是一个全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
self.t=DoExcle(project_path.case_path,case['sheet_name'])#写入测试结果的对象
#发起测试
my_log.info('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp=HttpRequest().http_request(method,url,param,cookies=COOKIES)#传参
#实实在在的http请求发生之后才去加一个判断，判断是否产生了cookies
if resp.cookies:#判断请求的cookies是否为空 不为空其实就是True
COOKIES=resp.cookies#我们可以更新COOKIES这个全局变量的值
try:
self.assertEqual(eval(case['ExpectedResult']),resp.json())
TestResult='Pass'#请注意这里
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e#处理完异常之后 不要留在家里 要抛出去！ raise e
finally:
self.t.write_back(case['CaseId']+1, 8, resp.text)#请注意这里
self.t.write_back(case['CaseId']+1, 9, TestResult)
my_log.info('实际结果：{}'.format(resp.json()))#http发送请求拿到的实际返回值
def test_cases(self, case):
global TestResult #全局变量
# global COOKIES#声明是一个全局变量
# 1:读取到测试数据
# 2:执行测试:遍历--根据Key取值
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# 发起测试
my_log.info('------正在测试{}模里面第{}条测试用例：{}'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
# 投资前查询数据库获取余额，保存
if case['sql'] != None:
sql = eval(case['sql'])['sql']
before_amount = DoMysql().do_mysql(sql)[0]
resp = HttpRequest().http_request(method,
url,
param,
cookies=getattr(GetData, 'COOKIE'))
#实实在在的http请求发生之后才去加一个判断，判断是否产生了cookies
if resp.cookies: #判断请求的cookies是否为空 不为空其实就是为True
setattr(GetData, 'COOKIE', resp.cookies) #我们可以更新COOKIES这个全局变量的值
# 投资后的查询数据库的余额
if case['sql'] != None:
sql = eval(case['sql'])['sql']
after_amount = DoMysql().do_mysql(sql)[0]
try:
self.assertEqual(eval(case['ExpectedResult']),
resp.json()) #http发送请求拿到的实际返回结果
#再加一个断言 与的关系
# # 投资后的查询数据库的余额
if case['sql'] != None:
sql = eval(case['sql'])['sql']
after_amount = DoMysql().do_mysql(sql)[0]
invest_amount = param['amount'] #实际的投资金额
expect_amount = before_amount - invest_amount
self.assertEqual(expect_amount, after_amount)
TestResult = 'Pass' #请注意这里
except Exception as e:
TestResult = 'Failed'
my_log.error('http请求出错了，错误是：{}'.format(str(e)))
raise e #处理完异常之后 不要留在家里 要抛出去
finally:
#写回结果
self.t.write_back(case['CaseId'] + 1, 9, resp.text) #请注意这里
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果为：{}'.format(resp.json())) #http发送请求拿到的实际返回值
def test_case(self, case):
global TestResult #全局变量
# global COOKIES #声明全局变量
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# 发起测试
my_log.info('-----正在测试{}模块第{}条用例：{}'.format(case['Module'],
case['CaseId'],
case['Title']))
my_log.info('测试数据是：{}'.format(case))
# 充值前查询数据库获取余额，保存
if case['Sql'] is not None:
sql = eval(case['Sql'])['sql']
before_amount = DoMySql().do_mysql(sql)[0]
resp = HttpRequest().http_request(
method, url, param,
cookies=getattr(GetData,
'COOKIE')) #http_request模块已经做了异常处理，所以在这里不用再做
#加一个判断
if resp.cookies: #判断请求的cookies是否为空 不为空其实就是True
setattr(GetData, 'COOKIE', resp.cookies) #我们可以更新COOKIES这个全局变量的值
try:
# 充值后查询数据库获取余额，保存
if case['Sql'] is not None:
sql = eval(case['Sql'])['sql']
after_amount = DoMySql().do_mysql(sql)[0]
recharge_amount = int(param['amount']) #将充值金额转成int类型
expect_amount = before_amount + recharge_amount
self.assertEqual(expect_amount, after_amount)
if case['ExpectedResult'].find('expectamount') > -1: #判断是否要做期望值的替换
case['ExpectedResult'] = case['ExpectedResult'].replace(
'expectamount', str(expect_amount))
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'Pass' # 请注意这里
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e #处理完异常之后要抛出去 raise
finally:
#写回测试结果
self.t.write_back(case['CaseId'] + 1, 9, resp.text)
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果:{}'.format(resp.json())) # http发送请求拿到的实际返回值
my_log.info('期望结果：{}'.format(eval(case['ExpectedResult'])))
def test_case(self, case):
global TestResult #全局变量
# global COOKIES #声明全局变量
method = case['Method']
url = case['Url']
# #替换loan_id
# if case['Params'].find('loanid')!=-1:
# param=eval(case['Params'].replace('loanid',str(getattr(GetData,'LOAN_ID'))))
# #因为拿到的值是int类型 replace的替换是字符串间的替换 所以要str()强转一下
# else:
# param = eval(case['Params'])
param = eval(get_data.replace(case['Params']))
# 发起测试
my_log.info('-----正在测试{}模块第{}条用例：{}'.format(case['Module'],
case['CaseId'],
case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(
method, url, param,
cookies=getattr(GetData,
'COOKIE')) #http_request模块已经做了异常处理，所以在这里不用再做
#判断是否要查询数据库
if case['Sql'] != None: #如果Sql语句不为None,那就是要进行数据库的查询操作
loan_id = DoMySql().do_mysql(
eval(case['Sql'])['sql'],
1) #返回的是元组 下一个请求要用到loan_id #eval()之后得到字典 再根据字典的key取值得到sql语句
setattr(GetData, 'loanid', str(loan_id[0])
) #利用反射 loan_id返回的是元组，所以根据索引取第一个值 loan_id[0]为int类型
#实实在在的http请求之后才去加一个判断，判断是否加cookies
if resp.cookies: #判断请求的cookies是否为空 不为空其实就是True
setattr(GetData, 'COOKIE', resp.cookies) #我们可以更新COOKIES这个全局变量的值
try:
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'Pass' # 请注意这里
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e #处理完异常之后要抛出去 raise
finally:
#写回测试结果
self.t.write_back(case['CaseId'] + 1, 9, resp.text)
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果:{}'.format(resp.json())) # http发送请求拿到的实际返回值
my_log.info('期望结果：{}'.format(eval(case['ExpectedResult'])))
def test_cases(self, case):
global TestResult # 全局变量
# global COOKIES#声明是一个全局变量
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# 发起测试
my_log.info('-------正在测试{}模块里面第{}条测试用例：{}'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
if case['sql'] is not None:
before_amount = DoMysql().do_mysql(eval(case['sql'])['sql'])[0]
resp = HttpRequest().http_request(method,
url,
param,
cookies=getattr(GetData,
'COOKIE')) # 传参
# 实实在在的http请求发生之后才去加一个判断，判断是否产生了cookies
if resp.cookies: # 判断请求的cookies是否为空 不为空其实就是True
setattr(GetData, 'COOKIE', resp.cookies) # 我们可以更新COOKIES这个全局变量的值
try:
if case['sql'] is not None:
after_amount = DoMysql().do_mysql(eval(case['sql'])['sql'])[0]
# 再加一个断言 与的关系
recharge_amount = int(param['amount'])
expected_amount = before_amount + recharge_amount
self.assertEqual(expected_amount, after_amount)
if case['ExpectedResult'].find('$amount') != -1:
case['ExpectedResult'] = case['ExpectedResult'].replace(
'$amount', str(expected_amount))
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'Pass' # 请注意这里
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e # 处理完异常之后 不要留在家里 要抛出去！ raise e
finally:
self.t.write_back(case['CaseId'] + 1, 9, resp.text) # 请注意这里
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果：{}'.format(resp.json())) # http发送请求拿到的实际返回值
def test_cases(self, case):
global TestResult #全局变量
# global COOKIES#声明是一个全局变量
method = case['Method']
url = case['Url']
#替换loan_id,mobilephone,pwd
# if case['Params'].find('loanid')!=-1:
# param=eval(case['Params'].replace('loanid',str(getattr(GetData,'LOAN_ID'))))#因为拿到的数据是int类型 replace只能用在字符串之间的替换 所以用str强转一下
# else:
# param=eval(case['Params'])#请求参数
params = eval(get_data.replace(case['Params']))
#发起测试
my_log.info('-------正在测试{}模块里面第{}条测试用例：{}'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(method,
url,
params,
cookies=getattr(GetData,
'COOKIE')) #传参
#判断是否要查询数据库
if case['sql'] != None: #如果sql语句不为None 那就是要进行数据库的查询操作
loan_id = DoMysql().do_mysql(
eval(case['sql'])['sql'],
1) #返回的是元组，所以我们存储数据的时候 最好是根据索引拿到值之后 再去做进一步操作
setattr(GetData, 'loanid', str(loan_id[0])) #利用反射
#实实在在的http请求发生之后才去加一个判断，判断是否产生了cookies
if resp.cookies: #判断请求的cookies是否为空 不为空其实就是True
setattr(GetData, 'COOKIE', resp.cookies) #我们可以更新COOKIES这个全局变量的值
try:
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'Pass' #请注意这里
except Exception as e:
# except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e #处理完异常之后 不要留在家里 要抛出去！ raise e
finally:
self.t.write_back(case['CaseId'] + 1, 9, resp.text) #请注意这里
self.t.write_back(case['CaseId'] + 1, 10, TestResult)
my_log.info('实际结果：{}'.format(resp.json())) #http发送请求拿到的实际返回值
def test_case(self,case):
global TestResult#全局变量
# global COOKIES #声明全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
# 发起测试
my_log.info('-----正在测试{}模块第{}条用例：{}'.format(case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
#投资前查询数据库获取余额，保存
if case['Sql'] is not None:
sql=eval(case['Sql'])['sql']
before_amount=DoMySql().do_mysql(sql)[0]
resp=HttpRequest().http_request(method, url, param,cookies=getattr(GetData,'COOKIE'))#http_request模块已经做了异常处理，所以在这里不用再做
#实实在在的http请求发生之后才去加一个判断，判断是否产生了cookies
if resp.cookies: # 判断请求的cookies是否为空 不为空其实就是True
setattr(GetData,'COOKIE',resp.cookies)#我们可以更新COOKIES这个全局变量的值
try:
self.assertEqual(eval(case['ExpectedResult']), resp.json())
#加一个断言，与的关系
# 投资后查询数据库的余额
if case['Sql'] is not None:
sql = eval(case['Sql'])['sql']
after_amount = DoMySql().do_mysql(sql)[0]
invest_amount=param['amount']#投资金额
expect_amount=before_amount - invest_amount
self.assertEqual(expect_amount,after_amount)
TestResult = 'Pass' # 请注意这里
except Exception as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e #处理完异常之后要抛出去 raise
finally:
#写回测试结果
self.t.write_back(case['CaseId']+1,9,resp.text)
self.t.write_back(case['CaseId']+1,10,TestResult)
my_log.info('实际结果:{}'.format(resp.json())) # http发送请求拿到的实际返回值
def test_cases(self, case):
global TestResult #全局变量
method = case['Method']
url = case['Url']
param = eval(case['Params'])
#发起测试
my_log.info('-------正在测试{}模块里面第{}条测试用例：{}'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(method, url, param)
try:
self.assertEqual(eval(case['ExpectedResult']), resp.json())
TestResult = 'Pass' #请注意这里
except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(e))
raise e #处理完异常之后 不要留在家里 要抛出去！ raise e
finally:
self.t.write_back(case['CaseId'] + 1, 8, resp.text) #请注意这里
self.t.write_back(case['CaseId'] + 1, 9, TestResult)
my_log.info('实际结果：{}'.format(resp.json())) #http发送请求拿到的实际