def test_withdraw(self, item):
"""
登录状态下，提现成功
:return:
"""
# 判断是否需要校验DB
if item['check_database'] != None:
Mylog().info("需要校验DB------{} ".format(item))
before_sql_result = DoMysql().do_mysql(
item['check_database']) # 获取调用接口前DB数据
Mylog().info("掉接口前sql获得的数据是{}".format(before_sql_result))
before_amount = before_sql_result[4]
before_freeze_amount = before_sql_result[5]
Mylog().info("提现前amount 是{},提现前freeze_amount 是{},待提现金额为{}".format(
before_amount, before_freeze_amount,
eval(item['data'])['amount']))
Mylog().info("开始调用接口")
res = HttpRequest().get_request(item['url'],
eval(item['data'])) #返回dict类型
after_sql_result = DoMysql().do_mysql(item['check_database'])
Mylog().info("掉接口后sql获得的数据是{}".format(before_sql_result))
after_amount = after_sql_result[4]
after_freeze_amount = after_sql_result[5]
Mylog().info("提现后amount 是{},提现后freeze_amount 是{},待提现金额为{}".format(
after_amount, after_freeze_amount,
eval(item['data'])['amount']))
# 判断数据是否更新正确
if after_freeze_amount == before_freeze_amount + eval(
item['data'])['amount']:
check_result = '数据库校验通过'
Mylog().info(check_result)
else:
check_result = '数据库未校验通过'
Mylog().info(check_result)
else:
res = HttpRequest().get_request(item['url'], eval(item['data']))
check_result = None
print(res, type(res))
try:
DoAssert().assert_code(item['expected'], res['code'])
# assert item['expected']==res.json()['code']
# self.assertEqual(item['expecxted'],res.json()['code'])
test_result = 'Pass'
except Exception as e:
test_result = 'Fail'
Mylog().error("执行用例失败{}".format(e))
raise e
finally:
pass
Mylog().info('获取到的结果是{}'.format(res))
DoExcel(test_data_path).write_back("gift_dealer_manage",
item['case_id'] + 1, str(res),
check_result, test_result)
def test_api(self, item):
passorfail = None
#请求之前完成loanid的替换
if item['data'].find('${loanid}') != -1:
if getattr(GetData, 'loanid') == None:
id = DoMysql.cnn_db(
'select max(id) from loan where memberid=82')[0]
item['data'] = str(item['data']).replace('${loanid}', str(id))
setattr(GetData, 'loanId', id) #利用反射去存储结果
else:
item['data'] = str(item['data']).replace(
'${loanid}', str(getattr(GetData, 'LoanId')))
#判断sql语句
if item['sql'] == None: #没有sql语句时
print('正在执行的用例是：第{}条用例'.format(item['case_id']))
res = HttpRequest().http_request(item['url'], eval(item['data']),
item['http_method'],
getattr(GetData, 'COOKIE'))
else: #有sql语句时
print('正在执行的用例是：第{}条用例'.format(item['case_id']))
sql = eval(item['sql'])['sql']
#http请求前
before_amount = DoMysql.cnn_db(sql)[0]
res = HttpRequest().http_request(item['url'], eval(item['data']),
item['http_method'],
getattr(GetData, 'COOKIE'))
#http请求后
after_amount = DoMysql.cnn_db(sql)[0]
amount = abs(after_amount - before_amount)
if str(amount) == str(eval(item['data'])['amount']):
check_res = '数据库校验正确'
else:
check_res = '数据库校验失败'
DoExcel.write_checkres(testcase_path, item['interface'],
item['case_id'], check_res)
print(res.json())
if res.cookies:
setattr(GetData, 'COOKIE', res.cookies)
try:
self.assertEqual(str(item['excepted']),
res.json()['code']) # 断言，没有断言默认不管对错测试用例都执行通过
passorfail = "成功"
except Exception as e:
print('失败用例{},{}：{}'.format(item['interface'], item['case_id'],
res.json()))
passorfail = "失败"
raise e
finally:
DoExcel.write_back(testcase_path, item['interface'],
item['case_id'], str(res.json()), passorfail)
def test_api(self, item):
global COOKIES #声明全局变量，必要的时候去更新从cookie的值
logging.info('正在执行第{0}条用例：{1}'.format(item['CaseId'], item['Title']))
logging.info('发起请求的地址是：{0}'.format(item['URL']))
logging.info('发起请求的参数是：{0}'.format(item['Param']))
res = HttpRequest().http_request(item["URL"],
eval(item["Param"]),
item["Method"],
cookies=COOKIES)
#登录请求之后会产生一个cookie
if res.cookies != {}: #如果cookie不为空 就对全局变量进行修改
COOKIES = res.cookies
# 断言
try:
self.assertEqual(item['ExpectedResult'], res.json()['Message'])
TestResult = 'PASS' #存储测试用例的执行结果 通过是PASS 失败是fail
except Exception as e:
logging.error('出错了，错误是：{0}'.format(e))
TestResult = 'FAIL'
raise e
finally:
self.t.write_back(item['CaseId'] + 1, 7, str(
res.json())) #因为Excel里面只能支持传递字符串和整数，所以这里要强制转换一下
self.t.write_back(item['CaseId'] + 1, 8, TestResult)
def test_case(self, case):
global result #声明全局变量
method = case['Method']
url = case['Url']
param = eval(case['Params'])
# print(param)
expected = eval(case['ExpectedResult'])
# # 查找替换mobilephone
# if case['Params'].find('normal_phone') != -1:
# param['mobilephone']=getattr(GetData,'normal_phone')
# # print(param)
# 调用正则函数替换mobilephone,pwd：TODO:只替换Params
param = eval(get_data.replace(case['Params']))
#发起测试
# print('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
self.my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'],
case['CaseId'],
case['Title']))
self.my_log.info('参数是：{}'.format(param))
res = HttpRequest() #实例化
resp = res.http_request(method, url, param, cookies=None)
print('实际结果：{}'.format(resp.json())) #http发送请求拿到的实际返回值
#对比结果
try:
self.assertEqual(expected, resp.json())
result = 'pass'
self.my_log.info('该条测试用例通过')
# print('该条测试用例通过')
except AssertionError as e:
result = 'failed'
self.my_log.error('该条测试用例不通过：'.format(e))
class TestCase:
@pytest.mark.parametrize('case',register_data)
@allure.feature("登录模块")
@allure.title("登录")
def test_register(self,case,init_api):
my_log = init_api
global result #声明全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
# print(param)
expected=eval(case['ExpectedResult'])
#发起测试
# print('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('参数是：{}'.format(param))
res=HttpRequest() #实例化
resp=res.http_request(method,url,param,cookies=None)
print('实际结果：{}'.format(resp.json()))#http发送请求拿到的实际返回值
#对比结果
try:
assert expected == resp.json()
result='pass'
my_log.info('该条测试用例通过')
# print('该条测试用例通过')
except AssertionError as e:
result='failed'
my_log.error('该条测试用例不通过：'.format(e))
def test_case(init_api): #传入测试数据整体
global result
method = init_api[0]['Method']
url = init_api[0]['Url']
param = eval(init_api[0]['Params']) # params 本身是一个字符串
expected_result = eval(init_api[0]['ExpectedResult']) # 本身也是一个字符串
# 发起测试
init_api[2].info('正在执行{}模块第{}条用例：{}'.format(init_api[0]['Module'],
init_api[0]['CaseId'],
init_api[0]['Title']))
init_api[2].info('参数是{}'.format(param))
# 实例化请求
res = HttpRequest()
resp = res.http_request(method, url, param, cookies=None)
print('实际结果是{}'.format(resp.json()))
# 对比
try:
assert expected_result == resp.json()
result = 'pass'
init_api[2].info('该条用例通过')
except Exception as e:
result = 'failed'
init_api[2].info('该条用例失败,{}'.format(e))
raise e
MyLog().info('本条用例结束')
def test_case(self,case): #传入测试数据整体
global result
method = case['Method']
url = case['Url']
param = eval(case['Params']) # params 本身是一个字符串
expected_result = eval(case['ExpectedResult']) # 本身也是一个字符串
# 发起测试
self.my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'], case['CaseId'], case['Title']))
self.my_log.info('参数是{}'.format(param))
# 实例化请求
res = HttpRequest()
resp = res.http_request(method,url,param,cookies=None)
print('实际结果是{}'.format(resp.json()))
# 对比
try:
self.assertEqual(expected_result,resp.json())
result = 'pass'
self.my_log.info('该条用例通过')
except Exception as e:
result = 'failed'
self.my_log.info('该条用例失败,{}'.format(e))
raise e
finally:
final_result = result
# 写会实际结果与是否通过
self.do_exl.write_back(case['CaseId']+1,8,resp.text) # TODO:注意是写回text，不能写回json
self.do_exl.write_back(case['CaseId']+1,9,final_result)
self.my_log.info('写入数据完毕')
self.my_log.info('本条用例结束')
def test_http_request(self, a):
# print("测试数据是:",a)
# print("目前正在执行第%s条用例"%a[0])
logger.info("测试数据是:{0}".format(a))
logger.info("目前正在执行第%s条用例" % a[0])
global COOKIES
# IP+a[4] ip地址与uri的拼接
res = HttpRequest(IP + a[4], a[5]).http_request(a[3], cookies=COOKIES)
if res.cookies != {}: # 判断长度或者是判断是否为空{}
COOKIES = res.cookies # 只有登录才会产生cookies
# print(res.json())
# 检查数据库
# eval(a[6])
print(a[7]['sql_data'])
print(type(a[7]['sql_data']))
sql_result = DoMysql().do_mysql(a[7]['sql'], (str(a[7]['sql_data']), ))
try:
self.assertEqual(str(sql_result), a[7]['expected'])
check_sql_result = 'PASS'
except AssertionError as e:
check_sql_result = 'FAIL'
raise e
finally:
self.t.write_data(a[0] + 1, 2, str(sql_result), check_sql_result)
try:
self.assertEqual(str(a[6]), res.json()['code'])
result = 'PASS'
# self.t.write_data(a[0]+1,str(res.json()),test_result)
except AssertionError as e:
result = 'Fail'
# self.t.write_data(a[0]+1,str(res.json()),test_result)
raise e # 跟return一样 中断代码
finally: #
self.t.write_data(a[0] + 1, 1, str(res.json()), result)
def test_cases(self, case):
global test_result
url = case['Url']
method = case['Method']
param = case['Param']
case_id = case['CaseId']
module = case['Module']
expected_result = case['ExpectedResult']
Log.info('用例参数为{}'.format(case))
actual_result = HttpRequest().http_request(
url, method, param, getattr(GetData, 'cookie')) # 返回 resp
if actual_result.cookies:
setattr(GetData, 'cookie', actual_result.cookies)
Log.info('第{}条{}模块用例，返回结果{}'.format(case_id, module,
actual_result.text))
try:
self.assertEqual(expected_result, actual_result.json())
test_result = 'Pass'
except Exception as e:
test_result = 'Fail'
Log.error(e)
raise e
finally:
Log.info(
'-----------------------------------------开始写回测试结果-----------------------------------------'
)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 8, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 9, test_result)
def _stores(cls):
headers = {
"Referer": "https://www.cvs.com/immunizations/covid-19-vaccine"
}
url = f"https://www.cvs.com/immunizations/covid-19-vaccine.vaccine-status.{cls.state}.json"
http = HttpRequest()
resp = http.get(url, headers)
data = resp.json()['responsePayloadData']['data'][cls.state]
return data
def test_cases(self, testdata):
res = HttpRequest().request_start(testdata["Method"],
eval(testdata["Params"]),
testdata["url"])
print(res)
try:
self.assertEqual(eval(testdata["ExpectedResult"]), res)
print("用例执行通过")
except AssertionError as e:
print("用例不通过，实际结果{}与预期结果{}不一致".format(
res, eval(testdata["ExpectedResult"])))
Mylog().log_debug(e)
raise e
finally:
self.case.write_excel(testdata["Case_id"] + 1, 8, str(res))
def latitude_longitude_from_address(cls, address):
print(f"Retrieving latitude and longitude for address {address}")
location = {'latitude': '', 'longitude': ''}
address = urllib.parse.quote(address)
api_url = f"{cls.API_BASE_URL}/search/{address}%20USA?format=json&addressdetails=1&limit=1"
http = HttpRequest()
resp = http.get(api_url)
loc_data = resp.json()[0]
print(
f"Found latitude {loc_data['lat']} and longitude {loc_data['lon']} for address {address}!"
)
location['latitude'] = loc_data['lat']
location['longitude'] = loc_data['lon']
return location
def test_cases(self, case):
global token
method = case['Method']
path = case['Path']
a = ReadConfig(project_path.conf_path).get_data('URL', 'agent_url')
url = a + path
params = eval(case['Params'])
headers = {'token': token}
#发起测试
my_log.info('-------正在测试【{}】模块里面第【{}】条测试用例：【{}】'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('-------接口URL:{}'.format(url))
my_log.info('-------接口入参:{}'.format(case["Params"]))
my_log.info('-------请求方式:{}'.format(method))
my_log.info('-------请求头headers:{}'.format(headers))
my_log.info('-------预期结果:{}'.format(case["ExpectedResult"]))
resp = HttpRequest().http_request(method, url, params,
headers=headers) #传参
#根据title取变量
if case['Title'] == '正常登录':
try:
token = resp.json()['token']
my_log.info('-------------登录成功取到token')
except Exception as e:
my_log.info('-----------登录失败没取到token')
raise e
try:
self.assertEqual(
json.loads(case['ExpectedResult'])['msg'],
resp.json()['msg'])
self.assertEqual(
json.loads(case['ExpectedResult'])['code'],
resp.json()['code'])
TestResult = 'Pass' #请注意这里
except Exception as e:
# except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(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_login(self, item):
self.logger.info("******************************")
self.logger.info("正在执行的用例是 {}".format(item["title"]))
self.logger.info("请求的数据是：{0}".format(item["data"]))
res = HttpRequest().http_request(item["url"], eval(item["data"]),
item["method"], item["type"])
try:
self.assertEqual(item["ExpectResult"], res.json()["message"])
TestResult = "PASS" # 如果不报错，测试通过
except AssertionError as e:
print("接口错误，错误是{}".format(e))
TestResult = "Fail" # 如果报错了，测试不通过
finally: # 不管测试结果是否正确，都把结果写入文件
self.logger.info("*********开始写入结果********")
self.t.write_back(item["case_id"] + 1, 8,
str(res.json()["message"])) # 写入实际结果
self.t.write_back(item["case_id"] + 1, 9, TestResult) # 写入测试结果
self.logger.info("*********结束写入数据********")
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:
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这个全局变量的值
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 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 vaccine_availability(cls):
print(
"Retrieving Walgreens COVID-19 vaccine appointment availablity data"
)
http = HttpRequest()
session = cls._csrf_token(http)
location = Geocoder.latitude_longitude_from_address(cls.zip_code)
headers = {
"Referer":
"https://www.walgreens.com/findcare/vaccination/covid-19/location-screening"
}
body = {
"serviceId": "99",
"position": {
"latitude": float(location['latitude']),
"longitude": float(location['longitude'])
},
"appointmentAvailability": {
"startDateTime": datetime.now().strftime('%Y-%m-%d')
},
"radius": 25
}
url = "https://www.walgreens.com/hcschedulersvc/svc/v1/immunizationLocations/availability"
resp = http.post(url, headers, body)
if resp.ok != True:
print(
f"Failed to connect to Walgreens. HTTP Response Code: {resp.status_code} Body: {resp.json()}"
)
return False
data = resp.json()
cls.availability = data['appointmentsAvailable']
if data['appointmentsAvailable'] == True:
print(f"Found available appointments at Walgreens!")
return True
else:
print(f"No Walgreens stores have available vaccine appointments.")
return False
def test_case2(self, case_2):
global result1
# url_login='******'
# param_login={'mobilephone':'18688775656','pwd':'123456'}
# method_login='******'
# # 获取到登录的cookies
# cookies=HttpRequest().http_request(method_login,url_login,param_login,cookies=None).cookies
url = case_2['Url']
param = eval(case_2['Params'])
method = case_2['Method']
expected = eval(case_2['ExpectedResult'])
# if case_2['Params'].find('normal_phone') != -1:
# param['mobilephone']=getattr(GetData,'normal_phone')
# 调用正则函数替换mobilephone，pwd：
param = eval(get_data.replace(case_2['Params']))
# print(param)
self.my_log.info('正在执行{}模块第{}条用例：{}'.format(case_2['Module'],
case_2['CaseId'],
case_2['Title']))
self.my_log.info('参数是：{}'.format(param))
resp = HttpRequest().http_request(
method, url, param, cookies=getattr(GetData,
'cookies')) #根据反射取值cookies
print('实际结果是：{}'.format(resp.json())) #发起请求的实际结果
if resp.cookies: #为真，即存在cookies
setattr(GetData, 'cookies', resp.cookies) #根据反射重新赋值cookies
# 对比结果
try:
self.assertEqual(expected['code'], resp.json()['code']) #对比code
result1 = 'pass'
self.my_log.info('该条测试用例通过')
except AssertionError as e:
self.my_log.error('该条测试用例不通过：{}'.format(e))
result1 = 'failed'
class TestCase:
# 登录注册
# @pytest.mark.moke
@pytest.mark.parametrize('case',login_data_new) # TODO 相当于ddt,case要与下面测试用例函数的参数一致
# @data(*login_data) # 加*解包，相当于遍历test_data传入函数，与加unpack的区别是：加入了unpack后，date里有几个参数，下面的函数就要传入几个变量
def test_case(self,case,init_api):
'''case 是上面传的测试用例数据'''
do_exl = init_api[0]
my_log = init_api[1]
global result #声明全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
# print(param)
expected=eval(case['ExpectedResult'])
# 调用正则函数替换mobilephone,pwd：TODO:只替换Params
param=eval(get_data.replace(case['Params']))
#发起测试
# print('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('参数是：{}'.format(param))
res=HttpRequest() #实例化
resp=res.http_request(method,url,param,cookies=None)
print('实际结果：{}'.format(resp.json()))#http发送请求拿到的实际返回值
# print('测试',type(resp.json()['code']))
#对比结果
try:
assert expected == resp.json()
result='pass'
my_log.info('该条测试用例通过')
# print('该条测试用例通过')
except AssertionError as e:
result='failed'
my_log.error('该条测试用例不通过：'.format(e))
def test(self, items):
case_id = items.case_id # 获取case_id
title = items.title # 获取title
method = items.method # 获取请求方法
url = ob.getstr('url', 'url') + items.url # 获取url地址
rp = Replace(section1='register', section2='login') # 创建替换对象
data = eval(rp.replace_data(items.data)) # 替换后的数据
except_result = items.except_result # 获取预期结果
print('第{}条用例开始执行：{}'.format(case_id, title))
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 打印日志
res = HttpRequest(url=url,
data=data).httprequest(method=method).content.decode(
'utf8') # 请求获取实际结果
print('实际结果为{}'.format(except_result))
print('预期结果为{}'.format(res))
# 比对实际与预期结果
try:
self.assertEqual(res, except_result)
if items.check_sql: # 如果需要数据库校验
sql = rp.replace_data(items.check_sql)
sql_result = self.ms.find_result(sql) # 数据库查询结果
if sql_result == 1: # 如果注册成功
ob.write('login', 'phone',
data['mobilephone']) # 将手机号写进配置文件
ob.write('login', 'pwd', data['pwd']) # 将密码写进配置文件
self.assertEqual(1, sql_result) # 比对查询结果
except AssertionError as e: # 若实际与预期不符
print('测试未通过')
self.excel.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
self.mylog.error('测试未通过,未通过信息为：{}'.format(e))
raise e # 抛出异常
else:
print('测试通过')
self.excel.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
self.mylog.info('测试通过') # 打印日志
finally:
self.excel.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def test_case(self,case):
global result #声明全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
# print(param)
expected=eval(case['ExpectedResult'])
#发起测试
# print('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
self.my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
self.my_log.info('参数是：{}'.format(param))
res=HttpRequest() #实例化
resp=res.http_request(method,url,param,cookies=None)
print('实际结果：{}'.format(resp.json()))#http发送请求拿到的实际返回值
#对比结果
try:
self.assertEqual(expected,resp.json())
result='pass'
self.my_log.info('该条测试用例通过')
# print('该条测试用例通过')
except AssertionError as e:
result='failed'
self.my_log.error('该条测试用例不通过：'.format(e))
def test_cases(self,testdata):
res=HttpRequest().request_start(ReadConf(SplitPsth().split_conf()).read_request_methoid(),eval(testdata["Params"]),testdata["url"])
# print(res)
b = res["code"] # 得到code的值
c = res["msg"] # 得到msg的值
# print(b)
# print(c)
ecpected = testdata["ExpectedResult"] # 得到预期结果
ecpect = eval(ecpected) # 转成原类型(字典)
b1 = ecpect["code"] # 得到code的值
c1 = ecpect["msg"] # 得到msg的值
try:
r = self.assertEqual(b, b1) # 比较code
r = self.assertEqual(c, c1) # 比较msg
print("正在执行用例【{}】：".format(testdata["Title"]))
print("用例通过，实际结果{}与预期结果{}一致".format(res, eval(testdata["ExpectedResult"])))
self.case.write_excel(testdata["Case_id"] + 1, 9, "PASS")
except AssertionError as e:
print("用例不通过，实际结果{}与预期结果{}不一致".format(res,eval(testdata["ExpectedResult"])))
self.case.write_excel(testdata["Case_id"] + 1, 9, "FAILED")
Mylog().log_debug(e)
raise e
finally:
self.case.write_excel(testdata["Case_id"]+1,8,str(res))
def test_api(self, item):
# global COOKIES
global REGTIME
global MEMBER_ID
res = HttpRequest(ip + item['url'], eval(item['param']),
item['method']).http_request()
# 每次请求之后判断是否产生cookies, 如果产生就替换全局变量，如果不产生，就不替换
# if res.cookies != {}:
# COOKIES = res.cookies
self.save.write_data(item['case_id'] + 1, 9, str(res))
# 每次请求之后查询一次数据库 对全局变量进行替换
# 替换regtime
if REGTIME == None:
query = "select regtime from member where mobilephone=%s"
query_condition = eval(item['param'])['mobilephone']
result = MySQLGetData().mysql_get_data(query, (query_condition, ),
1)
if result != None:
REGTIME = str(result[0]) + '.0'
# 替换member_id
if MEMBER_ID == None:
query = "select id from member where mobilephone=%s"
query_condition = eval(item['param'])['mobilephone']
result = MySQLGetData().mysql_get_data(query, (query_condition, ),
1)
if result != None:
MEMBER_ID = str(result[0])
# 判断期望结果里面是否有这些字段
if item['ExpectedResult'].find('${regtime}') != -1:
new_param_str = item['ExpectedResult'].replace(
'${regtime}', REGTIME)
if new_param_str.find('${member_id}') != -1:
new_param = eval(new_param_str)
#new_param = new_param.replace('${member_id}', MEMBER_ID)
new_param["data"]["id"] = int(MEMBER_ID)
new_param = str(new_param)
if new_param_str.find('${no_reg_tel}') != -1:
new_param = new_param.replace(
'${no_reg_tel}',
str(eval(item['param'])['mobilephone']))
else:
new_param = item['ExpectedResult']
if item['CheckSQL'] != None:
if item['CheckSQL'].find('${no_reg_tel}') != -1:
sql_param = item['CheckSQL'].replace(
'${no_reg_tel}', str(eval(item['param'])['mobilephone']))
query = eval(sql_param)['query']
query_condition = eval(sql_param)['query_condition']
result = MySQLGetData().mysql_get_data(query,
(query_condition, ), 1)
try:
self.assertEqual(int(result[0]),
int(eval(sql_param)['expected']))
sql_result = "Pass"
except AssertionError as e:
logger.error("执行用例时报错：{0}".format(e))
sql_result = "Fail"
raise e
finally:
self.save.write_data(item['case_id'] + 1, 11, sql_result)
try:
self.assertEqual(new_param, str(res))
test_result = "Pass"
except AssertionError as e:
logger.error("执行用例时报错：{0}".format(e))
test_result = "Fail"
raise e
finally:
self.save.write_data(item['case_id'] + 1, 10, test_result)
def test_cases(self, case):
global token
global aid
global shopid
global pid
method = case['Method']
path = case['Path']
a = ReadConfig(project_path.conf_path).get_data('URL', 'agent_url')
url = a + path
params = eval(case['Params'])
# 根据title定义请求参数
if case['Title'] == '一元商品详情':
params = {"shopId": shopid, "aid": aid}
if case['Title'] == '一元商品下单':
params = {
"orderType": "OneDollarRush",
"num": "1",
"pid": pid,
"shopId": "1121",
"aid": "1163"
}
my_log.info('chuancanla{}'.format(params))
if case['Title'] == '单笔数量超过20':
params = {
"orderType": "OneDollarRush",
"num": "50",
"pid": pid,
"shopId": "1121",
"aid": "1163"
}
headers = {'token': token}
#发起测试
my_log.info('-------正在测试【{}】模块里面第【{}】条测试用例：【{}】'.format(
case['Module'], case['CaseId'], case['Title']))
my_log.info('-------接口URL:{}'.format(url))
my_log.info('-------接口入参:{}'.format(params))
my_log.info('-------请求方式:{}'.format(method))
my_log.info('-------请求头headers:{}'.format(headers))
my_log.info('-------预期结果:{}'.format(case["ExpectedResult"]))
resp = HttpRequest().http_request(method, url, params, headers) #传参
#根据用例title取变量
if case['Title'] == '正常登录':
try:
token = resp.json()['token']
my_log.info('-------------登录成功取到token')
except Exception as e:
my_log.info('-----------登录失败没取到token')
raise e
if case['Title'] == '首页查询':
try:
aid = resp.json()['shops'][0]['aid']
shopid = resp.json()['shops'][0]['aid']
my_log.info('-----------------已获取活动aid:{},shopid:{}'.format(
aid, shopid))
except Exception as e:
my_log.error('-----------------未能取到活动aid')
if case['Title'] == '一元商品详情':
try:
pid = resp.json()['doboShop']['periodList'][0]['pid']
my_log.info('-----------------已获取最新周期pid:{}'.format(pid))
except Exception as e:
my_log.error('-----------------未取到最新周期pid')
try:
self.assertEqual(
json.loads(case['ExpectedResult'])['msg'],
resp.json()['msg'])
self.assertEqual(
json.loads(case['ExpectedResult'])['code'],
resp.json()['code'])
TestResult = 'Pass' #请注意这里
except Exception as e:
# except AssertionError as e:
TestResult = 'Failed'
my_log.error('http请求测试用例出错了，错误是：{}'.format(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发送请求拿到的实际返回值
from common.do_excel import DoExcel
from common.http_request import HttpRequest
from API_1.common import project_path
#完成用例的测试
#1:读取到测试数据
test_data = DoExcel(project_path.case_path, 'test_case').read_data()
#2:执行测试:遍历--根据Key取值
for case in test_data:
method = case['Method']
url = case['Url']
param = eval(case['Params'])
#发起测试
print('------正在测试{}模里面第{}条测试用例：{}'.format(case['Module'], case['CaseId'],
case['Title']))
resp = HttpRequest().http_request(method, url, param)
print('实际结果为：{}'.format(resp.json()))
#对比结果
if resp.json() == eval(case['ExpectedResult']):
TestResult = 'Pass'
else:
TestResult = 'Failed'
print('该条用例测试结论是：{}'.format(TestResult))
#需要写回什么？实际结果/测试结论
t = DoExcel(project_path.case_path, 'test_case')
t.write_back(case['CaseId'] + 1, 8, resp.text)
t.write_back(case['CaseId'] + 1, 9, TestResult)
# print(response.text)
import os
from common.project_path import *
url_21 = 'http://xiaolaiapi.yinglai.ren/api-file/app-api/app/upload'
param_1 = {
'token': Token,
'versionId': '10044',
'deviceType': 'ANDROID',
'appId': '1000',
'filename': ['test.jpg']
}
# headers={'token':Token,'versionId':'10044','deviceType':'ANDROID','appId':'1000'}
# files=[('file', open(os.path.join(picture_path,'test.jpg'),'rb'))]
#('file',open('D:\\Backup\\我的文档\\GitHub\\interface_automation\\interface\\picture\\xiaowang.jpg','rb'), 'image/jpg')]
http = HttpRequest(url_21, param_1).http_request('post')
# result_1=http.http_request('post').text
# result_1=requests.post(url_21,headers=headers,files=files).text
# print(result_1)
# print(http.text)
#shareDynId=0&shareTopicId=0&latitude=&address=&topicId=0&imageList=%5B%7B%22imageHeight%22%3A400%2C%22imageId%22%3A%224081%22%2C%22imageUrl%22%3A%22http%3A%2F%2Fxiaolaiimage.yinglai.ren%2Funsafe%2F2019%2F01%2F04%2F09450002034466974.jpg%22%2C%22imageWidth%22%3A400%7D%2C%7B%22imageHeight%22%3A750%2C%22imageId%22%3A%224082%22%2C%22imageUrl%22%3A%22http%3A%2F%2Fxiaolaiimage.yinglai.ren%2Funsafe%2F2019%2F01%2F04%2F09450006337185914.jpg%22%2C%22imageWidth%22%3A750%7D%5D&dynamicPath=&tok&location=&versionId=10044&appId=1000&deviceType=ANDROID&token=
url_3 = 'http://xiaolaiapi.yinglai.ren/api-moment/app-api/moments/publish'
image_list = json.dumps([{
'imageHeight': 1188,
'imageId': 4088,
'imageUrl':
'http://xiaolaiimage.yinglai.ren/unsafe/2019/01/10/14401300000928228.jpg',
'imageWidth': 1080
}])
# header={'Content-Type':'application/json; charset=UTF-8'}
print(type(image_list))
def setUpClass(cls):
cls.url = config.get("api", "url")
cls.request = HttpRequest()
cls.mysql = DoMysql()
def setUpClass(cls):
cls.http_request = HttpRequest()
def test_cases(self, case):
global test_result, cookie, before_amount
url = case['Url']
method = case['Method']
param = case['Param'] # 如Param参数中，有id这个key
if param.get('id'):
param['id'] = getattr(GetData, 'loan_id') # 把loan_id替换成id的value
if param.get('mobilephone'): # 把参数中的mobilephone参数化
param['mobilephone'] = getattr(GetData, 'mobilephone')
if param.get('pwd'): # 把参数中的pwd参数化
param['pwd'] = getattr(GetData, 'pwd')
if param.get('memberId'): # 把参数中的mobilephone参数化
param['memberId'] = getattr(GetData, 'memberId')
case_id = case['CaseId']
module = case['Module']
sql = case['Sql']
if sql is not None: # 把sql中的mobilephone参数化
if sql.get('sql'):
if sql['sql'].find('mobilephone') != -1:
sql['sql'] = sql['sql'].replace(
'mobilephone', str(getattr(GetData, 'mobilephone')))
expected_result = case['ExpectedResult']
if expected_result.get('data'): #参数化excepect_result中的电话号码
if expected_result['data'].get('mobilephone'):
expected_result['data']['mobilephone'] = str(
getattr(GetData,
'mobilephone')) #expect_result中mobilephone为str
Log.info('--用例参数为{}'.format(case))
if module == 'recharge' and case_id == 2 or module == 'add_loan' and case_id == 3: # 查询投资和充值前的金额
before_amount = DoMsq().my_sql(sql['sql'], 1)
actual_result = HttpRequest().http_request(url, method, param,
cookie) # 返回 resp
Log.info('--返回结果为:{}'.format(actual_result.json()))
if actual_result.cookies:
cookie = actual_result.cookies
Log.info('---第{}条{}模块用例，返回结果{}---'.format(case_id, module,
actual_result.text))
# a=sql['sql']
try:
if module == 'add_loan' and case_id == 2: # 取出加标后的loan_id
loan_id = DoMsq().my_sql(sql['sql'], 1)
setattr(GetData, 'loan_id', loan_id[0])
if module == 'recharge' and case_id == 2: # 查询充值后的金额
after_charge = DoMsq().my_sql(
sql['sql'], 1) # sql是返回一个元组，元组中元素什么类型取决于数据库字段类型
setattr(GetData, 'after_charge',
after_charge[0]) # 赋值给after_charge是数字类型
expected_result['data']['leaveamount'] = str(
getattr(GetData, 'after_charge'))
recharge_amount = getattr(GetData, 'after_charge') - int(
before_amount[0]) # 充值金额=充值后的金额-充值前的金额
self.assertEqual(recharge_amount,
int(param['amount'])) # 判断数据库中充值后的金额是否正确
if module == 'add_loan' and case_id == 3: # 查询投资后的金额
after_invest = DoMsq().my_sql(
sql['sql'], 1) # sql是返回一个元组，元组中元素什么类型取决于数据库字段类型
setattr(GetData, 'after_invest', after_invest[0])
invest_amount = before_amount[0] - getattr(
GetData, 'after_invest') # 投资金额=投资前的金额-投资后的金额
self.assertEqual(invest_amount,
int(param['amount'])) # 判断数据库中投资后的金额是否正确
self.assertEqual(expected_result, actual_result.json())
test_result = 'Pass'
except Exception as e:
test_result = 'Fail'
Log().error(traceback.format_exc())
raise e
finally:
Log.info('开始写回测试结果{}'.format(actual_result.json()))
if module == 'recharge':
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 10, test_result)
elif module in ('register', 'login'):
DoExcel(project_path.test_cases_path).write_excel(
'Sheet1', case_id + 1, 8, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'Sheet1', case_id + 1, 9, test_result)
elif module == 'withdraw':
DoExcel(project_path.test_cases_path).write_excel(
'withdraw', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'withdraw', case_id + 1, 10, test_result)
elif module == 'add_loan':
DoExcel(project_path.test_cases_path).write_excel(
'add_loan', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'add_loan', case_id + 1, 10, test_result)
elif module in ('audit', 'invest'):
DoExcel(project_path.test_cases_path).write_excel(
'audit', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'audit', case_id + 1, 10, test_result)
def test_login(self,case,init_api):
'''case 是上面传的测试用例数据'''
my_log = init_api
global result #声明全局变量
method=case['Method']
url=case['Url']
param=eval(case['Params'])
# print(param)
expected=eval(case['ExpectedResult'])
# 调用正则函数替换mobilephone,pwd：TODO:只替换Params
param=eval(replace(case['Params']))
#发起测试
# print('-------正在测试{}模块里面第{}条测试用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('正在执行{}模块第{}条用例：{}'.format(case['Module'],case['CaseId'],case['Title']))
my_log.info('参数是：{}'.format(param))
res=HttpRequest() #实例化
resp=res.http_request(method,url,param,cookies=None)
print('实际结果：{}'.format(resp.json()))#http发送请求拿到的实际返回值
# print('测试',type(resp.json()['code']))
#对比结果
try:
assert expected == resp.json()
result='pass'
my_log.info('该条测试用例通过')
# print('该条测试用例通过')
except AssertionError as e:
result='failed'
my_log.error('该条测试用例不通过：'.format(e))
# print('该条测试用例不通过:{}'.format(e))
def test_http_request(self, a):
logger.info("测试数据是：{0}".format(a)) #!!!括号中不能用逗号的方式传递变量值
logger.info("目前正在执行第%s条用例" % a['case_id'])
global COOKIES
logger.info("请求的地址为：%s" % (ip + a['url']))
logger.info("请求的参数为：%s" % a['params'])
# print('a5的类型',type(a[5]))
#此方法是针对list形式
# res=HttpRequest(ip+a[4],(a[5])).httpRequest(a[3],cookies=COOKIES)
#此方法是针对字典取值，可以根据key取value值
res = HttpRequest(ip + a['url'],
eval(a['params'])).httpRequest(a['method'],
cookies=COOKIES)
if res.cookies != {}: #判断cookies是否为空用{},或用len(res.cookies)==0
COOKIES = res.cookies
# print(res.json())
#检查数据库的值
# sql_result=DoMysql().do_mysql(a[7]['sql'],(str(a[7]['sql_data']),))
#判断是否对数据库进行检查
if a['check_sql'] != None: #是否需要对数据库进行检查
sql_result = DoMysql().do_mysql(eval(a['check_sql'])['sql'])
try:
self.assertEqual(
eval(a['check_sql'])['expected'], str(sql_result)
) #！！！a['check_sql]['expected'] 这种用法错误，应将前面转换成字典类型
check_sql_result = 'PASS'
except AssertionError as e:
check_sql_result = 'FAIL'
raise e
finally:
self.t.write_data(
int(a['case_id']) + 1, 2, str(sql_result),
check_sql_result)
#判断是否存在id和regtime需要替换
if a['expect_result'].find("${id}") != -1 and a['expect_result'].find(
'${regtime}') != -1:
#获取手机号 从params里面去获取手机号
mobilephone = eval(a['params'])['mobilephone'] #!!! 记住，字典的键值要用“”
#替换id
member_id = DoMysql().do_mysql(
'select id from member where mobilephone=%s' %
mobilephone)[0] #sql返回是元组类型
#替换regtime
regtime = DoMysql().do_mysql(
'select regtime from member where mobilephone=' +
mobilephone)[0]
expected_result = eval(a['expect_result'])
expected_result['data']['id'] = member_id
expected_result['data']['regtime'] = str(regtime) + '.0'
else:
expected_result = eval(a['expect_result'])
#检查excel中的预期值
try:
self.assertEqual(expected_result, res.json()) #!!!预期结果要转换成str
result = 'PASS'
except AssertionError as e:
logger.error("断言报错信息是%s" % e)
result = 'FAIL'
raise e #!!!终止后面的代码
finally:
self.t.write_data(
int(a['case_id']) + 1, 1, str(res.json()), result)