class Login_interface():
def __init__(self):
self.request = Request()
def login(self, domain, phoneNumber=None, password=None):
"""
用户注册
:param URL地址
:param 登录的手机号码
:param 登录的用户密码
:return: 返回登录信息
"""
url, data, header = request_data("login_interface", "login")
apiUrl = domain + url
data['phoneNumber'] = phoneNumber
data['password'] = password
response = self.request.post_request(apiUrl, data, header)
token = response['body']['data']['token']
appID = response['body']['data']['apps'][0]['appId']
return token, appID
def get_userToken(self, domain, appId, token):
"""
用户登陆
:param URL地址
:param 用户登陆appID
:return: 返回用户登陆后的token
"""
url, data, header = request_data("login_interface", "getUserToken")
apiUrl = domain + url
data['appId'] = appId
header['authorization'] = token
header['appid'] = appId
response = self.request.get_request(apiUrl, data, header)
token = response['body']['data']['token']
return token
def logout(self, domain, appId, token):
"""
退出登录
:param URL地址
:param 用户登陆appID
:return: 返回用户登陆后的token
"""
url, data, header = request_data("login_interface", "logout")
apiUrl = domain + url
header['authorization'] = token
header['appid'] = appId
response = self.request.get_request(apiUrl, data, header)
return response
class Login_interface():
def __init__(self):
self.request = Request()
def login(self, domain, lu=None, pd=None):
url, data, header = request_data("login_interface", "login")
apiUrl = domain + url
data['lu'] = lu
data['pd'] = pd
response = self.request.post_request(apiUrl, data, header)
return response
def get_userToken(self, domain, appId, token):
"""
用户登陆
:param URL地址
:param 用户登陆appID
:return: 返回用户登陆后的token
"""
url, data, header = request_data("login_interface", "getUserToken")
apiUrl = domain + url
data['appId'] = appId
header['authorization'] = token
header['appid'] = appId
response = self.request.get_request(apiUrl, data, header)
token = response['body']['data']['token']
return token
def logout(self, domain, appId, token):
"""
退出登录
:param URL地址
:param 用户登陆appID
:return: 返回用户登陆后的token
"""
url, data, header = request_data("login_interface", "logout")
apiUrl = domain + url
header['authorization'] = token
header['appid'] = appId
response = self.request.get_request(apiUrl, data, header)
return response
def __init__(self):
conf = Config()
self.request = Request.Request()
self.host = conf.host_debug
self.test = Assert.Assertions()
self.login = Login_interface()
self.g = globals()
def test_order_03(self):
"""
用例描述：购买单个产品-匹配同一方案下多个计费项（计费项下的策略有按包计费也有按量计费）-支付订单
"""
data = Order()
urls = data.url
params = data.data
header = data.header
request = Request.Request()
Asserts = Assert.Assertions()
conf = Config()
host = conf.host
req_url = 'http://' + host
api_url = req_url + urls[0]
sqlinfo = Mysql.Mysqlconnect()
# 创建订单
response = request.post_request(api_url, params[3], header[0])
assert Asserts.assert_in_text(response, 'order_id')
order_id = response['body']['order_id']
# 支付订单
url = req_url + urls[1].replace('{order_id}', order_id)
request.post_request(url, params[1], header[0])
#断言支付成功，数据库状态变为paid
info = sqlinfo.info(
'subscription',
'select order_status from prd_order where order_id = "%s"' %
order_id)
assert Asserts.assert_exist(info[0], 'paid')
def test_storeget_02(self, action):
"""
用例描述01：get查询门店无效的字符（####）
"""
conf = Config()
data = Storeget()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_get
req_url = 'http://' + host
print(req_url)
urls = data.url
params = data.data
headers = data.header
api_url = req_url + urls[1]
print(api_url)
response = request.get_request(api_url, params[1], headers[1])
# r = parse.unquote_plus(response["text"])
print(response)
# print(r)
assert test.assert_code(response['code'], 200)
# 这个需要url解码才能看出来，并且需要导入包from urllib import parse，S代表更新成功的意思
Consts.RESULT_LIST.append('True')
class TestBasic(object):
log = Log.MyLog()
data = Basic()
case_data = data.case_data
request = Request.Request()
test = Assert.Assertions()
config = Config()
noti = notify()
# ids = [
# "测试：{}".
# format(case['test_name']) for case in case_data
# ]
@allure.feature('Home')
@allure.severity('blocker')
@allure.story('Basic')
@allure.issue('https://baidu.com')
@allure.testcase('https://baidu.com')
@pytest.mark.flaky(reruns=3)
# @pytest.mark.parametrize('case', case_data, ids=ids)
@pytest.mark.parametrize('case', case_data)
def test_login(self,case):
"""
小程序登录
"""
self.log.info('demo, utl={}, data={}, header={}'.format(case['url'], case['data'], case['header']))
if case['method'] == 'post_request_urlencoded':
result = self.request.post_request_urlencoded(case['url'], case['data'], case['header'])
# 写入配置文件
self.config.set_conf('parameter', 'token', result['data']['token'])
assert self.test.assert_text(result['status'], 0)
self.log.info('配置文件中token ={}'.format(self.config.get_conf('parameter', 'token')))
allure.attach.file(BASE_PATH+'/Log/log.log', '附件内容是： ' + '老王调试日志', '我是附件名', allure.attachment_type.TEXT)
Consts.RESULT_LIST.append('True')
def test_user_01(self):
"""
用例描述：正常创建用户-正常创建角色-角色关联权限-用户关联角色
:return:usreid
"""
data = User()
urls = data.url
params = data.data
request = Request.Request()
Asserts = Assert.Assertions()
conf = Config()
host = conf.host
session = Session.Session()
token = session.get_session()[0]
print(token)
access_sys_id = session.get_session()[2]
header = {
'Authorization': "Bearer " + token,
'Content-Type': 'application/json'
}
# 创建用户
req_url_user = '******' + host + urls[0]
response = request.post_request(req_url_user, params[0], header)
assert Asserts.assert_in_text(response, 'user_id')
# 创建角色
req_url_roles = 'http://' + host + urls[1]
prs = {
"role_name": "角色名称",
"access_sys_id": access_sys_id,
"description": "角色描述"
}
response = request.post_request(req_url_roles, prs, header)
def test_getusermenu_01(self, action):
"""
用例描述：systemId、terminalType正常
"""
conf = Config()
data = GetUserMenu()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_base
req_url = 'http://' + host
urls = data.url
params = data.data
headers = data.header
he = {
'Content-Type': 'application/json;charset=UTF-8',
'token': "fbe62213-d9f6-4805-b239-1c232c5f2a9f"
}
api_url = req_url + urls[0]
response = request.post_request(api_url, json.dumps(he), headers[0])
print(json.dumps(he))
assert test.assert_code(response['body']['code'], '1003')
# assert test.assert_body(response['body'], 'description', '密码错误')
# assert test.assert_time(response['time_consuming'], 200)
Consts.RESULT_LIST.append('True')
def test_basic_01(self, action):
"""
不在活动时间内
"""
mysql = Mysql.Mysql()
time = Tools.acttime()
outtime = time[0]
print(outtime)
sql = "update 111 set `value` = '%s' where `key` = '111'" % outtime
mysql.update(sql) # 更改活动时间
Tools.refresh() # 刷新配置项
print("hello")
conf = Config()
data = MyTest()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_test
req_url = 'http://' + host
print(req_url)
urls = data.url
params = data.data
print(params)
headers = data.header
api_url = req_url + urls[0]
response = request.get_request(api_url, params[0], headers[0])
print(response)
# assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body'], 'code', '600000')
# assert test.assert_time(response['time_consuming'], 100)
Consts.RESULT_LIST.append('True')
def test_0002_a_precisefind(self):
"""
根据被保险人查询单子
:return:
"""
Con = Config()
test = Assertions()
allure = Allure()
reques = Request.Request(self.evn)
data = Basic()
urls = data.url
parms = data.data
headers = data.header
json_header = {'Authorization': 'bearer%s' % reques.get_session}
host = Con.host_debug
req_url = 'https://' + host
test_data=Con.get_conf(Con.TITLE_DATA, Config.VALUE_insuredPerson)
api_url = req_url + urls[0]['url_2']+ test_data
response = reques.get_request(api_url,json_header)
allure.allure_step('第一步','查询单子','根据被保险人，精准查询单子数量：%s'%response['jsons']['total'])
print('根据被保险人，精准查询单子数量：%s'%response['jsons']['total'])
assert test.assert_text(response['jsons']['total']>1,True)
def test_login_02(self, action):
"""
用例描述：密码错误数据
"""
# 写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已经开始执行')
conf = Config()
data = Login()
request = Request.Request(action)
#获取域名
host = conf.host_debug
req_url = 'http://' + host
#获取请求参数
urls = data.url
params = data.data
header = data.header
requestsql = data.selectsql
env = conf.environment
responsecode = data.responsecode
responsesql = data.responsesql
casedescription = data.casedec
#请求参数化
with allure.step("获取输入参数值,{0}".format(requestsql[1])):
try:
sqlresult = SqlResult(requestsql[1], env).get_sqlresult()
params[1][0]['auth'] = sqlresult['register_name']
except:
log.info("执行sql报错：：" + requestsql[1])
print(params[1][0])
# 请求接口
api_url = req_url + urls[1]
with allure.step("开始请求接口,RUL: {0},header:{1},request:{2}".format(
api_url, header[0], params[0][0])):
response = request.post_request(api_url, json.dumps(params[1][0]),
header[1])
print(response)
assertbody = Assertions()
assertbody.assert_text(str(response['code']), str(responsecode[1]))
with allure.step(
"增加断言,ResponseCode：{0}=TestCode：{1}，ResponseHeader：{2}".format(
response['code'], responsecode[1], response['header'])):
if (response['code'] == responsecode[1]):
#assertbody.assert_body(response['body'], 'message','密码错误')
assertbody.assert_body(response['header'], 'X-Api-Error-Code',
'ERR_LOGIN_FAILED')
else:
log.info("执行完成，Code不一致")
def test_updatehierarchy_03(self):
"""
用例描述：不变层级，名称重复
"""
# 写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已开始执行')
conf = Config()
data = UpdateHierarchy()
# 获取请求域名
host = conf.host_debug
req_url = 'http://' + host
# 获取请求参数
urls = data.url[2]
header = data.header[2]
param = data.data[2]
responsecode = data.responsecode[2]
sql_name = data.sqlname[2]
env = conf.environment
selectsql = data.selectsql[2]
errorcode = data.errorcode[2]
parentid = SqlResult(selectsql, env).get_sqlresult()
sqlname = str(sql_name).replace('@sqlresult', str(parentid['parent_id']))
pname = SqlResult(sqlname, env).get_sqlresult()
# 参数化请求参数
with allure.step("获取输入参数值"):
try:
param[0]['id'] = parentid['id']
param[0]['name'] = pname['name']
param[0]['parent_id'] = parentid['parent_id']
except:
log.info("获取参数失败：{0}".format(param[0]))
# 请求接口
api_url = req_url + urls
print(api_url)
print(param[0])
# post请求
request = Request.Request()
with allure.step("开始请求接口,RUL: {0},header:{1},request:{2}".format(api_url, header, param[0])):
response = request.post_request(api_url, json.dumps(param[0]), header)
print(response)
# 增加断言
with allure.step("接口返回结果：{0}".format(response)):
if response['code'] == responsecode:
assertbody = Assertions()
assertbody.assert_text(response['body'], errorcode)
class Role_interface():
def __init__(self):
self.request = Request()
def add_role(self, domain, cookie):
url, data, header = request_data("role_interface", "addRole")
apiUrl = domain + url
response = self.request.post_request(apiUrl, data, header, cookie)
return response
def find_role(self, domain, cookie):
url, data, header = request_data("role_interface", "findRoleByPage")
apiUrl = domain + url
response = self.request.post_request(apiUrl, data, header, cookie)
return response
def edit_role(self, domain, cookie, roleId):
url, data, header = request_data("role_interface", "updateRole")
apiUrl = domain + url
data["roleId"] = roleId
response = self.request.post_request(apiUrl, data, header, cookie)
return response
def delete_role(self, domain, cookie, roleId):
url, data, header = request_data("role_interface", "deleteRole")
apiUrl = domain + url
data["roleId"] = roleId
response = self.request.post_request(apiUrl, data, header, cookie)
return response
def test_enablehierarchy_02(self):
"""
用例描述：正常停用多个组织
"""
# 写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已开始执行')
conf = Config()
data = EnableHierarchy()
# 获取请求域名
host = conf.host_debug
req_url = 'http://' + host
# 获取请求参数
urls = data.url[1]
header = data.header[1]
param = data.data[1]
selectsql = data.selectsql[1]
responsecode = data.responsecode[1]
env = conf.environment
ids = SqlResult(selectsql, env).get_sqlresult_list()
myid = []
for i in range(len(ids)):
for k, v in ids[i].items():
myid.append(ids[i][k])
print(myid)
# 参数化请求参数
with allure.step("获取输入参数值"):
try:
param[0]['ids'].extend(myid)
except:
log.info("获取参数失败：{0}".format(param[0]))
# 请求接口
api_url = req_url + urls
# post请求
request = Request.Request()
with allure.step("开始请求接口,RUL: {0},header:{1},request:{2}".format(
api_url, header, param[0])):
response = request.post_request(api_url, json.dumps(param[0]),
header)
print(response)
# 增加断言
with allure.step("接口返回结果：{0}".format(response)):
if response['code'] == responsecode:
assertbody = Assertions()
assertbody.assert_text(response['body'], True)
def test_deletehierarchy_01(self):
"""
用例描述：正常删除一个层级
"""
#写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已开始执行')
conf = Config()
data = DeleteHierarchy()
#获取请求域名
host = conf.host_debug
req_url = 'http://' + host
# 获取请求参数
urls = data.url[0]
header = data.header[0]
param = data.data[0]
my_param = param[0]['id']
selectsql = data.selectsql[0]
responsecode = data.responsecode[0]
env = conf.environment
ids = SqlResult(selectsql, env).get_sqlresult()
# 参数化请求参数
with allure.step("获取输入参数值"):
try:
param[0]['id'].append(ids['id'])
except:
log.info("获取参数失败：{0}".format(param[0]))
#请求接口
api_url = req_url + urls
print(api_url)
#post请求
request = Request.Request()
with allure.step("开始请求接口,RUL: {0},header:{1},request:{2}".format(
api_url, header, param[0])):
response = request.post_request(api_url, json.dumps(my_param),
header)
print(response)
# 增加断言
with allure.step("接口返回结果：{0}".format(response)):
if response['code'] == responsecode:
assertbody = Assertions()
assertbody.assert_text(response['body'], True)
def test_hierarchy_01(self):
"""
用例描述：获取目录
"""
#写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已开始执行')
conf = Config()
data = GetHierarchy()
#获取请求域名
host = conf.host_debug
req_url = 'http://' + host
env = conf.environment
responsesql = data.responsesql
responsecode = data.responsecode
# 获取请求参数
urls = data.url
header = data.header
#请求接口
api_url = req_url + urls
request = Request.Request()
with allure.step("开始请求接口,RUL: {0},header:{1}".format(api_url, header)):
response = request.get_request(api_url, None, header)
print(response['body'])
# 数据库查询结果
try:
# print(responsesql)
responsesqlresult = SqlResult(responsesql, env).get_sqlresult_list()
print(responsesqlresult)
with allure.step("获取预期结果值成功"):
log.info('查询结果数据库成功：' + responsesql)
except:
log.info('查询结果数据库失败：' + responsesql)
print(responsecode)
# 增加断言
assertbody = Assertions()
with allure.step("增加断言，接口返回结果：{0}".format(response)):
assertbody.assert_text(str(response['code']), str(responsecode))
if response['code'] == responsecode:
for i in range(len(responsesqlresult)):
for k, v in responsesqlresult[i].items():
assertbody.assert_body(response['body'][i], k, responsesqlresult[i][k])
def test_0001_add(self):
"""创建新单"""
Con=Config()
test=Assertions()
allure=Allure()
reques= Request.Request(self.evn)
data=Basic()
urls=data.url
parms=data.data
headers=data.header
Con.set_item(Con.TITLE_DATA,Con.VALUE_policyNo,self.create_time() + '-' + self.create_unix())
Con.set_item(Con.TITLE_DATA,Con.VALUE_reportNo,self.create_time() + '-' + self.create_unix())
Con.set_item(Con.TITLE_DATA,Con.VALUE_reporttime,self.create_time())
policyNo = Con.get_conf(Con.TITLE_DATA, Config.VALUE_policyNo)
reportNo = Con.get_conf(Con.TITLE_DATA, Config.VALUE_reportNo)
json_data ={'reportDate':self.create_now_time(),
"insuranceComName": Con.insuranceComName,
"insuredPerson": Con.insuredPerson,
"policyNo":policyNo,
"reportNo":reportNo,
}
data_new =dict(parms[0],**json_data)
json_header={'Authorization': 'bearer %s' % reques.get_session}
header_new=dict(headers[0],**json_header)
host = Con.host_debug
req_url ='https://'+ host
api_url = req_url + urls[0]['url_1']
response = reques.post_request(api_url,json.dumps(data_new), header_new)
allure.allure_step('第一步', '添加单子',(response['stats']))
assert test.assert_code(response['code'], 200)
assert test.assert_text((response['stats'])['success'],True)
#查询事故号：
req_url_1 = 'https://' + host
url_find = req_url_1+ urls[0]['url_2']+'&policyNo='+ policyNo+'&reportDate='
res = reques.get_request(url_find,json_header)
Con.set_item(Con.TITLE_DATA, Con.VALUE_reporttid,res['jsons']['rows'][0]['id'])
allure.allure_step('第二步', '查询单子','事故号id为：%s' %res['jsons']['rows'][0]['id'])
print('事故号id为：%s' %res['jsons']['rows'][0]['id'])
def test_get_project_list(self, get_project_list, action):
"""
:param get_project_list: 获取项目列表
:param action: 环境参数
"""
request = Request.Request(action)
# params = data.data
api_url = get_project_list["url"]
api_header = get_project_list["header"]
response = request.get_request(api_url, None, api_header)
assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body'], 'code', 1)
assert test.assert_body(response['body'], 'message', '操作成功')
assert test.assert_time(response['time_consuming'], 500)
Consts.RESULT_LIST.append('True')
def test_import_user(self, import_user, action):
"""
:param import_user: 导入用户
:param action: 环境参数
:return:
"""
request = Request.Request(action)
api_url = import_user["url"] # 获取请求地址
api_header = import_user["header"] # 获取请求头
api_body = import_user["body"] # 获取请求体
response = request.post_request_multipart(api_url, api_body, api_header, "file", Common.Consts.ADMIN_NAME) # 发送请求
assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body'], 'code', 1)
assert test.assert_body(response['body'], 'message', '操作成功')
assert test.assert_time(response['time_consuming'], 500)
Consts.RESULT_LIST.append('True')
def test_getproduct_01(self, action):
"""
用例描述：测试get1
"""
with allure.step("用例开始"): # 步骤2，step的参数将会打印到测试报告中
allure.attach('test2', '开始测试'),
log = Log.MyLog()
log.info('文件已经开始执行')
conf = Config()
data = AddToCart()
request = Request.Request(action)
host = conf.host_debug
port = conf.portShopService_debug
req_url = 'http://' + host + ':' + port
print(req_url)
urls = data.url
params = data.data
header = data.header
requestsql = data.requestsql
responsecode = data.responsecode
#responsesql = data.responsesql
#connection=SqlResult.connect_mysql()
with allure.step('请求参数：'): # 步骤2，step的参数将会打印到测试报告中
allure.attach(str(urls[0]), '请求url')
allure.attach(str(params[0][0]), '请求参数：')
allure.attach(str(urls[0]), '请求heder：')
sqlresult = SqlResult(requestsql[0], 'debug').get_sqlresult()
print(sqlresult['id'])
api_url = req_url + urls[0]
#print(api_url)
print(params[0][0])
params[0][0]['memberId'] = 7
print(params[0][0])
#print(header[0])
response = request.post_request(api_url, params[0][0], header[0])
with allure.step('执行测试完成：'): # 步骤2，step的参数将会打印到测试报告中
allure.attach(str(response['code']), '请求结果')
allure.attach(str(response['body']), '请求结果体')
assert response['code'] == responsecode[0]
def test_addhierarchy_07(self):
"""
用例描述：name字段传空
"""
# 写log
with allure.step("写入Log"):
log = Log.MyLog()
log.info('文件已经开始执行')
conf = Config()
data = AddHierarchy()
# 获取请求域名
host = conf.host_debug
req_url = 'http://' + host
# 获取请求参数
urls = data.url[4]
header = data.header[4]
param = data.data[4]
env = conf.environment
responsecode = data.responsecode[4]
responsesql = data.responsesql[4]
selectsql = data.selectsql[4]
errorcode = data.errorcode[4]
print(param[0])
# 请求接口
api_url = req_url + urls
print(api_url)
# post请求
request = Request.Request()
with allure.step("开始请求接口,RUL: {0},header:{1},request:{2}".format(
api_url, header, param[0])):
response = request.post_request(api_url, json.dumps(param[0]),
header)
print(response)
# 增加断言
with allure.step("接口返回结果：{0}".format(response)):
if response['code'] == responsecode:
assert response['body']
assertbody = Assertions()
assertbody.assert_text(response['header']['X-Api-Error-Code'],
errorcode)
def test_personal_02(self, action):
"""
用例描述：登陆状态下更新Personal个人简介
"""
conf = Config()
data = Personal()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
headers = data.header
api_url = req_url + urls[1]
response = request.post_request(api_url, params[1][0], headers[1])
assert response['code'] == 200
Consts.RESULT_LIST.append('True')
def login(action):
conf = Config()
data = Login()
request = Request.Request(action)
host = conf.host_debug
req_url = 'https://' + host
urls = data.url
api_url = req_url + urls[0]
params = data.data
# print(params[0][0])
response = request.post_request(api_url, params[0][0])
re = json.loads(response)
token = re['data']['token']
pid = re['data']['id']
# print(pid)
return token, pid
def test_03(self, action):
"""
用例描述：验证首页按指定统计门店数据
"""
conf = Config()
data = Index()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
api_url = req_url + urls[2]
response = request.get_request(api_url, params[2])
assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body'], 'message', u'请求成功')
assert test.assert_time(response['time_consuming'], 1000)
Consts.RESULT_LIST.append('True')
def test_collections_02(self, action):
"""
用例描述：查看用户'95c34f9cc50c'的Collections
"""
conf = Config()
data = Collections()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
headers = data.header
api_url = req_url + urls[1]
response = request.post_request(api_url, params[1], headers[1])
assert test.assert_code(response['code'], 208)
assert test.assert_in_text(response['body'], '每日一篇技术文')
Consts.RESULT_LIST.append('True')
def test_collections_01(self, action):
"""
用例描述：查看用户'da1677475c27'的Collections
"""
conf = Config()
data = Collections()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
headers = data.header
api_url = req_url + urls[0]
response = request.post_request(api_url, params[0], headers[0])
assert test.assert_code(response['code'], 200)
assert test.assert_in_text(response['body'], '软件测试-各种技能集合')
Consts.RESULT_LIST.append('True')
def test_login_01(self, action):
"""
正常登录
"""
conf = Config()
data = Login()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'https://' + host
urls = data.url
api_url = req_url + urls[0]
params = data.data
# print(params[0][0])
response = request.post_request(api_url, params[0][0])
re = json.loads(response)
assert test.assert_text(re['data']['userName'], 'ouyangnana')
def test_01(self, action):
"""
用例描述：验证保理1订单列表搜索筛选功能
"""
conf = Config()
data = OrderList()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
api_url = req_url + urls[0]
response = request.get_request(api_url, params[0])
assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body']['data']['list'][0], 'id', 735)
assert test.assert_time(response['time_consuming'], 300)
Consts.RESULT_LIST.append('True')
def refresh():
"""
刷新配置项
"""
url = "http://**.***.**.**:18089/*******/flush/config"
params = {
"address": "**.***.**.**:3099",
"referer": "http://**.***.**.**:8080/*************/manage/index"
}
headers = {
"Host": "**.***.**.**:18089",
"Origin": "http://**.***.**.**:18089",
"Referer": "http://**.***.**.**:18089/*****/flushList?type=config"
}
request = Request.Request("activity")
rsp = request.post_request(url=url, data=params, header=headers)
print(rsp)
def test_01(self, action):
"""
用例描述：验证新增企业CA是否成功
"""
conf = Config()
data = CreateCa()
test = Assert.Assertions()
request = Request.Request(action)
host = conf.host_debug
req_url = 'http://' + host
urls = data.url
params = data.data
api_url = req_url + urls[0]
response = request.post_request(api_url, params[0])
assert test.assert_code(response['code'], 200)
assert test.assert_body(response['body'], 'message', u'CA申请信息提交成功')
assert test.assert_time(response['time_consuming'], 1000)
Consts.RESULT_LIST.append('True')
