def __init__(self, sheet_name):
Handle.__init__(self)
# 1.sheet_name
self.sheet_name = sheet_name
# 2.token
self.token = self.get_token()
self.token1 = self.get_token1()
# 3. 创建请求对象
self.R = RequestForHttp()
# 4.获取excel中行数据
self.excel = Excel(xls='data_api.xls', sheet_name=self.sheet_name)
self.data = self.excel.get_row_data(sheet_name=self.sheet_name)
# 5.关联字典
# 关联字典
self.correlationDict = {}
self.checkDict = {}
# 其中内置了四个参数，分别是：
# ${token}（token令牌值）
# ${randomTel}（随机手机号码）
# ${timestamp}（当前时间戳）
# ${session}（session#id，默认为None）
# ${hashPassword}（hash加密密码，明文123456）
self.correlationDict['${self.token}'] = self.token
self.correlationDict['${self.token1}'] = self.token1
self.correlationDict['${space_name}'] = 'api测试'
def __init__(self):
# 1.创建读取配置信息对象
cf = GlobalParam('config', 'path_file.conf')
# 2.获取截图路径、日志路径、日志名
self.logfile = cf.getParam('log', "logfile") # 日志文件名
# 3.创建日志记录模块
self.log = Log(self.logfile)
# 4.创建DataInfo操作对象
self.excel = Excel(xls='data_api.xls', sheet_name='test2')
class LogInfo():
def __init__(self):
# 1.创建读取配置信息对象
cf = GlobalParam('config', 'path_file.conf')
# 2.获取截图路径、日志路径、日志名
self.logfile = cf.getParam('log', "logfile") # 日志文件名
# 3.创建日志记录模块
self.log = Log(self.logfile)
# 4.创建DataInfo操作对象
self.excel = Excel(xls='data_api.xls', sheet_name='test2')
def print_log(self, reponse, sheet_name):
'''
打印日志模块
:param data: 请求数据
:param response: 返回值
:param describle: 接口描述
:param url: 接口地址
:param method: 请求方法
:param header: 头文件
:return:
'''
data = self.excel.get_row_data(sheet_name=sheet_name)
for i in range(0, len(data)):
api_no = data[i][0]
api_name = data[i][1]
api_describle = data[i][2]
api_url = data[i][3]
api_function = data[i][4]
api_headers = data[i][5]
api_data = data[i][6]
api_check = data[i][7]
api_hope = data[i][8]
self.log.info('1.接口编号 : {0}'.format(api_no))
self.log.info('2.接口名称 : {0}'.format(api_name))
self.log.info('3.接口描述 : {0}'.format(api_describle))
self.log.info('4.接口路由 : {0}'.format(api_url))
self.log.info('5.接口方式 : {0}'.format(api_function))
self.log.info('6.接口头部 : {0}'.format(api_headers))
self.log.info('7.接口数据 : {0}'.format(api_data))
self.log.info('8.接口检查 : {0}'.format(api_check))
self.log.info('9.接口预期 : {0}'.format(api_hope))
self.log.info('X.接口返回 : {0}\n'.format(reponse[1]))
def __init__(self, sheet_name):
Handle.__init__(self)
# 1.sheet_name
self.sheet_name = sheet_name
# 2.token
# self.token = self.get_token()
# self.token1 = self.get_token1()
# self.token88 = self.get_token88()
# self.token89 = self.get_token89()
# 正式环境token
'''
pro :正式环境token
'''
# self.token_list = self.get_token_list(env='pro')
'''
获取EnvManage.py文件中的env变量，设定环境
test : 测试环境
pro : 正式环境
dev : 开发环境
'''
from YunluFramework_API.config import EnvManage
self.token_list = self.get_token_list(env=EnvManage.env)
self.token = self.token_list[0][0]
self.token1 = self.token_list[0][1]
self.token88 = self.token_list[0][2]
self.token89 = self.token_list[0][3]
self.token90 = self.token_list[0][4]
self.token91 = self.token_list[0][5]
self.token92 = self.token_list[0][6]
self.token93 = self.token_list[0][7]
self.token94 = self.token_list[0][8]
self.token95 = self.token_list[0][9]
self.token96 = self.token_list[0][10]
self.token97 = self.token_list[0][11]
self.token98 = self.token_list[0][12]
self.token99 = self.token_list[0][13]
# 3. 创建请求对象
self.R = RequestForHttp()
# 4.获取excel中行数据
self.excel = Excel(xls='data_api.xls', sheet_name=self.sheet_name)
self.data = self.excel.get_row_data(sheet_name=self.sheet_name)
# 5.关联字典
# 关联字典
self.correlationDict = {}
# self.checkDict = {}
# 其中内置了四个参数，分别是：
# ${token}（token令牌值）
# ${randomTel}（随机手机号码）
# ${timestamp}（当前时间戳）
# ${session}（session#id，默认为None）
# ${hashPassword}（hash加密密码，明文123456）
# self.correlationDict['${self.token}'] = self.token
# self.correlationDict['${self.token1}'] = self.token1
# self.correlationDict['${self.token88}'] = self.token88
# self.correlationDict['${self.token89}'] = self.token89
# self.correlationDict['${space_name}'] = 'api测试'
self.correlationDict = {
'${self.token}': self.token,
'${self.token1}': self.token1,
'${self.token88}': self.token88,
'${self.token89}': self.token89,
'${self.token90}': self.token90,
'${self.token91}': self.token91,
'${self.token92}': self.token92,
'${self.token93}': self.token93,
'${self.token94}': self.token94,
'${self.token95}': self.token95,
'${self.token96}': self.token96,
'${self.token97}': self.token97,
'${self.token98}': self.token98,
'${self.token99}': self.token99,
'${space_name}': 'api测试'
}
class API_REQUEST(Login):
def __init__(self, sheet_name):
Handle.__init__(self)
# 1.sheet_name
self.sheet_name = sheet_name
# 2.token
# self.token = self.get_token()
# self.token1 = self.get_token1()
# self.token88 = self.get_token88()
# self.token89 = self.get_token89()
# 正式环境token
'''
pro :正式环境token
'''
# self.token_list = self.get_token_list(env='pro')
'''
获取EnvManage.py文件中的env变量，设定环境
test : 测试环境
pro : 正式环境
dev : 开发环境
'''
from YunluFramework_API.config import EnvManage
self.token_list = self.get_token_list(env=EnvManage.env)
self.token = self.token_list[0][0]
self.token1 = self.token_list[0][1]
self.token88 = self.token_list[0][2]
self.token89 = self.token_list[0][3]
self.token90 = self.token_list[0][4]
self.token91 = self.token_list[0][5]
self.token92 = self.token_list[0][6]
self.token93 = self.token_list[0][7]
self.token94 = self.token_list[0][8]
self.token95 = self.token_list[0][9]
self.token96 = self.token_list[0][10]
self.token97 = self.token_list[0][11]
self.token98 = self.token_list[0][12]
self.token99 = self.token_list[0][13]
# 3. 创建请求对象
self.R = RequestForHttp()
# 4.获取excel中行数据
self.excel = Excel(xls='data_api.xls', sheet_name=self.sheet_name)
self.data = self.excel.get_row_data(sheet_name=self.sheet_name)
# 5.关联字典
# 关联字典
self.correlationDict = {}
# self.checkDict = {}
# 其中内置了四个参数，分别是：
# ${token}（token令牌值）
# ${randomTel}（随机手机号码）
# ${timestamp}（当前时间戳）
# ${session}（session#id，默认为None）
# ${hashPassword}（hash加密密码，明文123456）
# self.correlationDict['${self.token}'] = self.token
# self.correlationDict['${self.token1}'] = self.token1
# self.correlationDict['${self.token88}'] = self.token88
# self.correlationDict['${self.token89}'] = self.token89
# self.correlationDict['${space_name}'] = 'api测试'
self.correlationDict = {
'${self.token}': self.token,
'${self.token1}': self.token1,
'${self.token88}': self.token88,
'${self.token89}': self.token89,
'${self.token90}': self.token90,
'${self.token91}': self.token91,
'${self.token92}': self.token92,
'${self.token93}': self.token93,
'${self.token94}': self.token94,
'${self.token95}': self.token95,
'${self.token96}': self.token96,
'${self.token97}': self.token97,
'${self.token98}': self.token98,
'${self.token99}': self.token99,
'${space_name}': 'api测试'
}
def print_log(self, api_no, api_name, api_describe, api_url, api_function,
api_headers, api_data, api_check, api_status, api_hope,
response):
'''
打印日志模块
:param api_no : 接口编号
:param api_name : 接口名称
:param api_describe : 接口描述
:param api_url : 接口地址
:param api_function : 接口方法
:param api_headers : 接口头部
:param api_data : 接口数据
:param api_check : 接口检查
:param api_hope : 接口预期
:param response : 接口返回
:return:
'''
self.log.info('1. 接口编号 : {0}'.format(api_no))
self.log.info('2. 接口名称 : {0}'.format(api_name))
self.log.info('3. 接口描述 : {0}'.format(api_describe))
self.log.info('4. 接口路由 : {0}'.format(api_url))
self.log.info('5. 接口方式 : {0}'.format(api_function))
self.log.info('6. 接口头部 : {0}'.format(api_headers))
self.log.info('7. 接口数据 : {0}'.format(api_data))
self.log.info('8. 接口检查 : {0}'.format(api_check))
self.log.info('9. 预期状态 ：{0}'.format(api_status))
self.log.info('10.接口预期 : {0}'.format(api_hope))
if api_status == 204:
self.log.info('11.接口返回 : {0}'.format(response[1]))
else:
self.log.info('11.接口返回 : {0}'.format(response[1]))
def api_method(self, method, api_url, api_headers, data=None):
'''
请求方式选择器
:param method : 请求方式
:param api_url : 接口路由
:param data : 请求数据
:param api_headers : 请求头
:return:
'''
if method == 'GET':
response = self.R.get_function(api_url, data)
return response
elif method == 'POST':
response = self.R.post_function(api_url, data, api_headers)
return response
elif method == 'DELETE':
response = self.R.delete_function(api_url, data)
return response
elif method == 'PUT':
response = self.R.put_function(api_url, data)
return response
else:
pass
'''
通用的接口请求方法,返回接口的response值
'''
def api_requests(self, api_no, api_name, api_describe, api_url,
api_function, api_headers, api_data, api_check, api_hope,
api_status, api_correlation, api_messages):
'''
公用请求方法
:param api_no : 接口编号
:param api_name : 接口名称
:param api_describe : 接口描述
:param api_url : 接口地址
:param api_function : 接口方法
:param api_headers : 接口头部
:param api_data : 接口数据
:param api_check : 接口检查
:param api_hope : 接口预期
:return : 接口返回 response[0] - 状态码 | response[1] - 返回值
'''
# 0 解析请求头，如果为json类型，将str类型的headers转换成字典类型
if api_headers == "{'Content-Type':'application/json'}":
# 1）将header转换成字典格式
api_headers = eval(api_headers)
# 2）直接将api_data转换成json格式
self.data = self.analysis_data(api_data) # 字典格式
self.data = json.dumps(self.data) # json字符串
# 3）解析url
api_url = self.analysis_url(api_url)
# 1 如果api_headers为空
if api_headers == '':
# 1.解析data 和 url ———— 将data转为字典格式
try:
# 1.1解析测试数据
self.data = self.analysis_data(api_data)
# 1.2 解析url
api_url = self.analysis_url(api_url)
except Exception as e:
# 1.1 将请求数据转换成字典
self.data = api_data
self.data = eval(self.data)
# 1.2 解析url
api_url = self.analysis_url(api_url)
self.log.error(e)
# 2. 发送请求
# 2.1 发送请求
response = self.api_method(
method=api_function,
api_url=api_url,
data=self.data,
api_headers=api_headers)
# 2.2 打印日志
# 2.1 > 如果状态码不为204
if api_status != 204:
# 3. 打印日志
# 如果self.data是json字符串，就先把他转换成字典在打印出来
if isinstance(self.data, str):
self.data = json.loads(self.data)
self.print_log(api_no, api_name, api_describe, api_url,
api_function, api_headers, self.data, api_check,
api_hope, api_status, response)
# 4.解析返回值
status_code = response[0] # 状态码
response1 = json.loads(response[1]) # 解析返回值
self.analysis_response(api_no, api_name, api_correlation,
response1)
# 5.解析关联消息
self.analysis_messages(api_no, api_name, api_messages)
return status_code, response1
# 2.2 > 如果状态码为204
elif api_status == 204:
# 3.解析返回值
status_code = response # 状态码
response1 = ''
response = [status_code, response1]
# 4. 打印日志
# 如果self.data是json字符串，就先把他转换成字典在打印出来
if isinstance(self.data, str):
self.data = json.loads(self.data)
self.print_log(api_no, api_name, api_describe, api_url,
api_function, api_headers, self.data, api_check,
api_hope, api_status, response)
# 5.解析关联消息
self.analysis_messages(api_no, api_name, api_messages)
# return status_code, response1
return response
# # 2. 发送请求
# # 2.1 > 如果状态码不为204
# if api_status != 204:
#
# # 2. 发送请求
# response = self.api_method(method=api_function, api_url=api_url, data=data, api_headers=api_headers)
#
# # 3. 打印日志
# self.print_log(api_no, api_name, api_describe, api_url, api_function, api_headers,
# data, api_check, api_hope, api_status, response)
#
# # 4.解析返回值
# status_code = response[0] # 状态码
# response1 = json.loads(response[1]) # 解析返回值
# self.analysis_response(api_no, api_name, api_correlation, response1)
#
# # 5.解析关联消息
# self.analysis_messages(api_no, api_name, api_messages)
#
# return status_code, response1
#
# # 2.2 > 如果状态码为204，返回结果为【no content】
# elif api_status == 204:
#
# # 2.发送请求
# response = self.api_method(method=api_function, api_url=api_url, data=data, api_headers=api_headers)
#
# # 3.解析返回值
# status_code = response # 状态码
# response1 = ''
# response = [status_code, response1]
#
# # 4. 打印日志
# self.print_log(api_no, api_name, api_describe, api_url, api_function, api_headers,
# data, api_check, api_hope, api_status, response)
#
# # 5.解析关联消息
# self.analysis_messages(api_no, api_name, api_messages)
#
# return status_code, response1
'''
用于解析返回值中的数据和请求数据中的关联项
'''
# 用于解析请求地址(api_data)
def analysis_url(self, api_url):
'''
用于解析url地址
:param api_url : 接口路由
:return:
'''
# 1.替换api_data中的关联项
for k in self.correlationDict:
if (api_url.find(k)) > 0:
# 此处将id team_id等参数获取到后转换成str类型
api_url = api_url.replace(k, str(self.correlationDict[k]))
return api_url
# 用于解析请求数据(api_data)
def analysis_data(self, api_data):
'''
用于解析关联数据，将需要关联的字段存到关联字典中
:param api_data : 接口请求数据
:return:
'''
# 1.请求数据：字符串转字典
dic_api_data = eval(api_data)
# 2.循环遍历测试数据
for k in dict(dic_api_data):
for key in self.correlationDict:
if dic_api_data[k] == key:
dic_api_data[k] = self.correlationDict[key]
return dic_api_data
# 用于解析返回值(response)
def analysis_response(self, api_no, api_name, correlation, response):
'''
用于解析返回值中的数据，将这些数据存入关联字典中以供使用
:param response : 接口返回值
:return:
'''
# 如果关联数据不为空
if correlation != '':
# 1.处理关联数据(存到列表中)
correlation = correlation.replace('\n', '').replace('\r',
'').split(';')
# 2.分解关联数据
for j in range(len(correlation)):
param = correlation[j].split('=')
# 3.判断处理后的关联列表长度为2时
if len(param) == 2:
if param[1] == '' or not re.search(
r'^\[', param[1]) or not re.search(
r'\]$', param[1]):
self.log.error(
api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Correlation]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
value = response
# 5.继续处理correlation
a = param[1][1:-1].split('][')
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
self.correlationDict[param[0]] = value
return self.correlationDict
# 用于解析检查点
def analysis_check(self, api_no, api_name, api_check, response):
'''
用于检查点的校验
:param response : 接口返回值
:return:
'''
# 标志符
flag = ''
# 如果检查数据不为空
if api_check != '':
# 1.处理关联数据(存到列表中)
api_check = api_check.replace('\n', '').replace('\r',
'').split(';')
# 2.分解关联数据
for j in range(len(api_check)):
# 判断是否为'='关系
if '=' in api_check[j]:
# 如果 '#len#' 存在
if '#len#' in api_check[j]:
param = api_check[j].split('=#len#')
flag = '#len#'
# 如果 '#len#'不存在
elif '#len#' not in api_check[j]:
param = api_check[j].split('=')
flag = '='
# 判断是否为'<>'关系
elif '<>' in api_check[j]:
param = api_check[j].split('<>')
flag = '<>'
# 3.判断处理后的关联列表长度为2时
if len(param) == 2:
if param[1] == '' or not re.search(
r'^\[', param[1]) or not re.search(
r'\]$', param[1]):
self.log.error(api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Check]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
value = response
# 5.继续处理api_check
a = param[1][1:-1].split('][')
# print('***********&&&&&&&&&&&&&&&&&',a)
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
# 替换检查点中的关联数据
# self.log.debug('self.correlationDict = {0}'.format(
# self.correlationDict))
for k in self.correlationDict:
if param[0] == k:
self.log.debug('param[0] = {0}'.format(param[0]))
param[0] = self.correlationDict[k]
self.log.debug('字典关键字为:{0}'.format(k))
self.log.debug('param[0] = {0}'.format(param[0]))
try:
self.log.debug('----------进入检查点数据校验-------------')
self.log.debug('检查项' + str(a))
# self.log.debug('检查项: ' + '[' +a[0]+ ']'+'['+ a[1]+']')
# print("----------进入检查点数据校验-------------")
self.log.debug('flag = {0}'.format(flag))
# 检查点数据校验
# '='关系断言
if flag == '=':
self.log.debug('进入等于')
# 1. 如果检查项中为空列表，读出来的是字符串，则将字符串转换成空列表
if param[0] == '[]':
param[0] = []
# 2. 如果检查项中为None，读出来的是字符串，则将字符串转换成None类型
if param[0] == 'None':
param[0] = None
# 3. 如果检查项中为{}，读出来的是字符串，则将字符串转换成{}类型
if param[0] == '{}':
param[0] = {} # 转换成字典
self.log.debug('进入等于阶段后的---->预期param[0] = {0}'.format(
param[0]))
self.log.debug(
'进入等于阶段后的---->type(param[0]) 值 = {0}'.format(
type(param[0])))
self.log.debug(
'进入等于阶段后的---->实际value 值 = {0}'.format(value))
self.log.debug(
'进入等于阶段后的---->type(value) 值 = {0}'.format(
type(value)))
# 如果返回值解析结果value值是数值，先将check中解析出来的param[0]的值转为int再断言
if type(value) == int:
self.log.debug('进入if')
assert int(param[0]) == value
self.log.debug('true | value = {0}'.format(value))
# 20180410 10:36加入
# return [True, value]
elif type(value) == float:
self.log.debug('进入elif1')
assert float(param[0]) == value
self.log.debug('true | value = {0}'.format(value))
# 将value值中的True或False的类型转换成str类型，再与param[0]断言
# 先判断传进来的parma[0]的类型是否为str类型，如果是才能和'True'/'False'比较
elif param[0] == 'True' or param[0] == 'False':
self.log.debug('进入elif2')
value = str(value)
assert param[0] == value
self.log.debug('true | value = {0}'.format(value))
# 20180410 10:36加入
# return [True, value]
# 无需转换时，直接比较检查点
else:
self.log.debug('进入else')
self.log.debug('param[0] = {0}'.format(param[0]))
self.log.debug('value = {0}'.format(value))
assert param[0] == value
self.log.debug('true | value = {0}'.format(value))
# 20180410 10:36加入
# return [True, value]
# '<>'关系断言
if flag == '<>':
self.log.debug('进入不等于')
# 1. 如果检查项中为空列表，读出来的是字符串，则将字符串转换成空列表
if param[0] == '[]':
param[0] = []
# 2. 如果检查项中为None，读出来的是字符串，则将字符串转换成None类型
if param[0] == 'None':
param[0] = None
# 3. 如果检查项中为{}，读出来的是字符串，则将字符串转换成{}类型
if param[0] == '{}':
param[0] = {} # 转换成字典
self.log.debug('进入不等于阶段后的---->预期param[0] = {0}'.format(
param[0]))
self.log.debug(
'进入不等于阶段后的---->type(param[0]) 值 = {0}'.format(
type(param[0])))
self.log.debug('进入不等于阶段后的---->实际value 值 = {0}'.format(
type(value)))
self.log.debug(
'进入不等于阶段后的---->type(value) 值 = {0}'.format(
type(value)))
# 如果返回值解析结果value值是数值，先将check中解析出来的param[0]的值转为int再断言
if type(value) == int:
self.log.debug('进入if')
assert int(param[0]) != value
self.log.debug('true | value = {0}'.format(value))
# 20180410 10:36加入
# return [True, value]
elif type(value) == float:
self.log.debug('进入elif1')
assert float(param[0]) != value
self.log.debug('true | value = {0}'.format(value))
# 将value值中的True或False的类型转换成str类型，再与param[0]断言
# 先判断传进来的parma[0]的类型是否为str类型，如果是才能和'True'/'False'比较
elif param[0] == 'True' or param[0] == 'False':
self.log.debug('进入elif2')
value = str(value)
assert param[0] != value
self.log.debug('true | value = {0}'.format(value))
# 20180410 10:36加入
# return [True, value]
# 无需转换时，直接比较检查点
else:
self.log.debug('进入else')
self.log.debug('param[0] = {0}'.format(param[0]))
self.log.debug('value = {0}'.format(value))
assert param[0] != value
self.log.debug('true | value = {0}'.format(value))
# '#len#'关系断言
if flag == '#len#':
self.log.debug('进入#len#')
self.log.debug('int(parma[0]) = {0}'.format(
int(param[0])))
self.log.debug('len(value) = {0}'.format(len(value)))
assert len(value) == int(param[0])
self.log.debug('true | len(value) = {0}'.format(
len(value)))
# 20180410 10:36加入
# return [True, value]
except Exception as e:
self.log.error('进入exception')
self.log.error('Exception : {0}'.format(e))
self.log.error('false | value = {0}'.format(value))
return [False, value]
return [True, value]
# 获取leancloud系统消息记录
def get_Messages_from_leancloud(self):
import requests
url = "https://3bxid9fg.api.lncld.net/1.1/rtm/messages/history"
headers = {
'X-LC-Id': "3BXiD9Fga5RtswdyrJSFQ3h3-gzGzoHsz",
'X-LC-Sign':
"7396816f73bdbcf70281b09dc2c1b3b9,1517046641139,master",
}
# 1.发送请求
with requests.Session() as s:
response = s.get(url, headers=headers)
# 2.解析返回内容
res = response.text
# 3.转为字典
dict_r = json.loads(res)
# 转为json,并格式化输出
json_r = json.dumps(
dict_r,
sort_keys=True,
ensure_ascii=False,
indent=4,
separators=(',', ': '))
return json_r
# 获取发送给某个用户的(忽略发送着的身份【system】|【user】)最新一条消息的【data】数据
def get_first_message(self, to_who):
# 1.调用消息记录模块,返回消息记录列表
re1 = self.get_Messages_from_leancloud()
re1 = json.loads(re1)
# 2.循环存消息
messages = []
for i in re1:
if i['to'] == to_who:
messages.append(i)
else:
pass
message_1 = messages[0]
# 3.解析第一条数据
dict1 = message_1['data']
data = dict1 = json.loads(dict1)
# 4.直接取出id
# dict1 = dict1['_lcattrs']['id']
# 5.格式化输出
# message_1 = json.dumps(message_1, sort_keys=True, ensure_ascii=False, indent=4, separators=(',', ': '))
# print(message_1)
# print(dict1)
# 6.返回message_1,类型为字典
return data
# 解析发给某个用户的最新一条消息的关联数据
def analysis_messages(self, api_no, api_name, correlation):
'''
用于解析返回值中的数据，将这些数据存入关联字典中以供使用
:return:
'''
# 如果关联数据不为空
if correlation != '':
# 1.处理关联数据(存到列表中)
correlation = correlation.replace('\n', '').replace('\r',
'').split(';')
# 2.分解关联数据
for j in range(len(correlation)):
correlation = correlation[j].split('=')
# 3.判断处理后的关联列表长度为2时
if len(correlation) == 2:
if correlation[1] == '' or not re.search(
r'^\[', correlation[1]) or not re.search(
r'\]$', correlation[1]):
self.log.error(
api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Correlation]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
'''
临时方案，此时推送给的用户id是写死的，token1的用户
'''
value = self.get_first_message(
to_who='d66dcb63-107f-4d30-a632-d97882b7465f')
# 5.继续处理correlation
a = correlation[1][1:-1].split('][')
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
self.correlationDict[correlation[0]] = value
return self.correlationDict
class SpaceAPI_Private(unittest.TestCase):
'''
全局接口数据：持续更新
'''
# 全局数据: 获取excel中行数据
# request = API_REQUEST(sheet_name='test2')
# excel1 = Excel(xls='data_api.xls', sheet_name='test2')
# data = excel1.get_row_data(sheet_name='test2')
'''
20180417 - 订单退货退款流程接口测试
'''
# request = API_REQUEST(sheet_name='refund')
# excel1 = Excel(xls='data_api.xls', sheet_name='refund')
# data = excel1.get_row_data(sheet_name='refund')
'''
20180504 - 订单退货退款流程接口测试1
'''
# request = API_REQUEST(sheet_name='refund1')
# excel1 = Excel(xls='data_api.xls', sheet_name='refund1')
# data = excel1.get_row_data(sheet_name='refund1')
'''
20180507 - 权限模块检查
'''
# request = API_REQUEST(sheet_name='cando')
# excel1 = Excel(xls='data_api.xls', sheet_name='cando')
# data = excel1.get_row_data(sheet_name='cando')
'''
20180628
'''
# request = API_REQUEST(sheet_name='test2')
# excel1 = Excel(xls='data_api.xls', sheet_name='test2')
# data = excel1.get_row_data(sheet_name='test2')
'''
20180708 - 帖子功能接口测试
'''
# request = API_REQUEST(sheet_name='topics')
# excel1 = Excel(xls='data_api.xls', sheet_name='topics')
# data = excel1.get_row_data(sheet_name='topics')
'''
20180712 - 肖静远 & lin 测试发帖子功能
'''
# request = API_REQUEST(sheet_name='topics')
# excel1 = Excel(xls='data_api.xls', sheet_name='topics')
# data = excel1.get_row_data(sheet_name='topics')
'''
20180807 - 肖静远 测试资讯投票功能
'''
request = API_REQUEST(sheet_name='collection')
excel1 = Excel(xls='data_api.xls', sheet_name='collection')
data = excel1.get_row_data(sheet_name='collection')
# 1.类开始
@classmethod
def setUpClass(self):
# 1.创建读取配置信息对象
cf = GlobalParam('config', 'path_file.conf')
# 2.获取截图路径、日志路径、日志名
self.logfile = cf.getParam('log', "logfile") # 所有运行日志文件名
self.errfile = cf.getParam('log', 'errfile') # 错误日志文件
# 3.创建日志记录模块
self.log = Log(self.logfile) # 所有日志
self.err = Log(self.errfile) # 错误日志
# 4.打印日志
self.log.info(
'****************************************SpaceAPI_Private：开始****************************************'
)
# # 5.创建登录对象
# self.S = Space()
# 2.类结束
@classmethod
def tearDownClass(self):
# 1.打印日志
self.log.info(
'****************************************SpaceAPI_Private：结束****************************************\n'
)
# 3.测试方法开始
def setUp(self):
self.log.info(
'------------------------------------用例开始------------------------------------'
)
# 4.测试方法结束
def tearDown(self):
self.log.info(
'------------------------------------用例结束------------------------------------\n'
)
# 4.测试用例
@ddt.data(*data)
def test01_api(self, list):
'''
:param list: 参数化列表
:return:
'''
# 1.控制器
api_no = list[0] # 接口编号]
api_name = list[1] # 接口名称
api_describe = list[2] # 接口描述
api_url = list[3] # 接口路由
api_function = list[4] # 接口方法
api_headers = list[5] # 接口头部
api_data = list[6] # 接口数据
api_check = list[7] # 接口检查
api_hope = list[8] # 接口预期
api_active = list[10] # 接口执行
api_status = list[11] # 预期状态
api_correlation = list[12] # 接口关联
api_message = list[13] # 消息关联
# 2.用例执行
response = ''
status_code = ''
if api_active == 'YES':
try:
# 发送请求
response = self.request.api_requests(
api_no=api_no,
api_name=api_name,
api_describe=api_describe,
api_url=api_url,
api_function=api_function,
api_headers=api_headers,
api_data=api_data,
api_check=api_check,
api_hope=api_hope,
api_status=api_status,
api_correlation=api_correlation,
api_messages=api_message)
# 解析状态码-实际状态码
status_code = response[0]
# 解析返回值
response = response[1]
except Exception as e:
self.log.error('Exception Information : {0}'.format(e))
self.err.error('Exception Information : {0}'.format(
traceback.format_exc()))
# 断言1:status状态码是否正确
try:
assert status_code == api_status
except AssertionError as e:
self.log.error('返回状态码错误！实际返回状态码为:{0}\n'.format(status_code) +
traceback.format_exc())
self.err.error('1. 接口编号 : {0} | 接口名称 : {1} '.format(
api_no, api_name))
# self.err.error('2. 状态信息 : 预期结果={0} | 实际结果={1}'.format(
# api_status, status_code))
self.err.error('2. 错误信息 : {0}'.format(traceback.format_exc()))
assert False, '返回状态码错误！实际返回状态码为:{0}'.format(status_code)
# 断言2:返回值是否为空
# 状态码为204时
if status_code == 204:
try:
assert response == ''
except AssertionError as e:
self.log.error('204状态下返回值应该为空！' + traceback.format_exc())
self.err.error('1. 接口编号 : {0} | 接口名称 : {1} '.format(
api_no, api_name))
self.err.error('2. 204状态下返回值应该为空！')
self.err.error('3. 错误信息 : {0}'.format(
traceback.format_exc()))
assert False, '204状态下返回值应该为空,当前实际不为空！'
# 状态码不为204时
else:
try:
assert response != ''
except AssertionError as e:
self.log.error('返回值为空！\n' + traceback.format_exc())
self.err.error('1. 接口编号 : {0} | 接口名称 : {1} '.format(
api_no, api_name))
self.err.error('2. 返回值为空！')
self.err.error('3. 错误信息 : {0}'.format(
traceback.format_exc()))
assert False, '返回值应该不为空,当前实际返回值为空！'
# 断言3:检查点数据校验
# 如果api_check不为空：
try:
if api_check != '':
# 3.1 存储检查结果
api_check_result = self.request.analysis_check(
api_no=api_no,
api_name=api_name,
api_check=api_check,
response=response)
# 3.2 断言判断，检查False是否不等于检查结果，如果等于就报错
assert False != api_check_result[0]
else:
pass
except AssertionError as e:
self.log.error("'检查点:{0} | 实际返回结果:{1} | 结果错误,错误信息:{2}".format(
api_check, api_check_result[1], traceback.format_exc()))
self.err.error('1. 接口编号 : {0} | 接口名称 : {1} '.format(
api_no, api_name))
# self.err.error("2. 检查信息 : {0} | 实际返回结果:{1} ".format(
# api_check,
# api_check_result[1],
# ))
self.err.error('2. 错误信息 : {0}'.format(traceback.format_exc()))
assert False, '检查点:{0} | 结果错误，错误信息:{1}'.format(api_check, e)
# 断言4:返回值是否符合预期
# 如果api_hope不为空:
if api_hope != '':
# 1> 先将api_hope通过json解析成对应的格式
api_hope = json.loads(api_hope)
# 2> 断言
try:
assert api_hope == response
except AssertionError as e:
self.log.error('实际结果与预期结果不符！' + traceback.format_exc())
self.err.error('1. 接口编号 : {0} | 接口名称 : {1} '.format(
api_no, api_name))
# self.err.error('2. 返回信息 ：预期返回={0} | 实际返回={1}'.format(
# api_hope, response))
self.err.error('2. 错误信息 : {0}'.format(
traceback.format_exc()))
assert False, '实际结果与预期结果不符！'
else:
pass
# 3.用例不执行
elif api_active == 'NO':
# self.log.info(list)
self.log.info('未执行测试用例编号 : {0} | 名称 : {1}'.format(
api_no, api_name))
pass
class SpaceAPI_Private(unittest.TestCase, SpaceAPI_Dada):
# 声明数据库操作对象
d = DataMysql()
excel = DataInfo(path='data_api.xls')
result = Excel(xls='data_api.xls', sheet_name='SPACE')
# 私人空间创建：私人空间name
data_test03_Space_private_create_api = d.select(
sql='select * from Space_private_create_api_table')[0][0]
sql01 = 'select * from test_SpaceAPI_01'
sql03 = 'select * from test_SpaceAPI_02'
# 6.获取excel中行数据
request = API_REQUEST(sheet_name='test2')
excel1 = Excel(xls='data_api.xls', sheet_name='test2')
data = excel1.get_row_data(sheet_name='test2')
# 1.类开始
@classmethod
def setUpClass(self):
# 1.创建读取配置信息对象
cf = GlobalParam('config', 'path_file.conf')
# 2.获取截图路径、日志路径、日志名
self.logfile = cf.getParam('log', "logfile") # 日志文件名
# 3.创建日志记录模块
self.log = Log(self.logfile)
# 4.打印日志
self.log.info(
'****************************************SpaceAPI_Private：开始****************************************'
)
# 5.创建登录对象
self.S = Space()
# 2.类结束
@classmethod
def tearDownClass(self):
# 1.打印日志
self.log.info(
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~SpaceAPI_Private：结束~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n'
)
# 3.测试方法开始
def setUp(self):
# 1.查询私人空间更新：私人空间id
self.data_test05_Space_update_id_api = self.d.select(
sql='select * from Space_update_id_api_table')[0][0]
# 2.私人空间文件夹更新：私人空间文件夹id
self.data_test07_Space_folder_update_id_api = self.d.select(
sql='select * from Space_folder_update_id_api_table')[0][0]
# 4.测试用例
@ddt.data(*data)
def test_api(self, list):
# 1.控制器
# for i in range(0, len(self.data)):
# api_no = self.data[i][0] # 接口编号
# api_name = self.data[i][1] # 接口名称
# api_describe = self.data[i][2] # 接口描述
# api_url = self.data[i][3] # 接口路由
# api_function = self.data[i][4] # 接口方法
# api_headers = self.data[i][5] # 接口头部
# api_data = self.data[i][6] # 接口数据
# api_check = self.data[i][7] # 接口检查
# api_hope = self.data[i][8] # 接口预期
# api_active = self.data[i][10] # 接口执行
# api_status = self.data[i][11] # 预期状态
# api_correlation = self.data[i][12] # 接口关联
api_no = list[0] # 接口编号
api_name = list[1] # 接口名称
api_describe = list[2] # 接口描述
api_url = list[3] # 接口路由
api_function = list[4] # 接口方法
api_headers = list[5] # 接口头部
api_data = list[6] # 接口数据
api_check = list[7] # 接口检查
api_hope = list[8] # 接口预期
api_active = list[10] # 接口执行
api_status = list[11] # 预期状态
api_correlation = list[12] # 接口关联
# 2.用例执行
response = ''
status_code = ''
if api_active == 'YES':
try:
# 发送请求
response = self.request.api_requests(
api_no=api_no,
api_name=api_name,
api_describe=api_describe,
api_url=api_url,
api_function=api_function,
api_headers=api_headers,
api_data=api_data,
api_check=api_check,
api_hope=api_hope,
api_status=api_status,
api_correlation=api_correlation)
# 解析状态码
status_code = response[0]
# 解析返回值
response = response[1]
except Exception as e:
self.log.error('Exception Information : {0}'.format(e))
# 断言1:返回值是否为空
try:
assert response != ''
except Exception as e:
self.log.error('返回值为空！\n')
assert False, '返回值为空！'
# 断言2:status状态码是否正确
try:
assert status_code == api_status
except Exception as e:
self.log.error('返回状态码错误！实际返回状态码为:{0}\n'.format(status_code))
assert False, '返回状态码错误！实际返回状态码为:{0}'.format(status_code)
# 断言3:检查点数据校验
# 如果api_check不为空：
try:
if api_check != '':
assert True == self.request.analysis_check(
api_check=api_check, response=response)
else:
pass
except Exception as e:
self.log.error('检查点:{0} | 结果错误,错误信息:{1}'.format(api_check, e))
assert False, '检查点:{0} | 结果错误，错误信息:{1}'.format(api_check, e)
# 断言4:返回值是否符合预期
# 如果api_hope不为空:
if api_hope != '':
# 1> 先将api_hope通过json解析成对应的格式
api_hope = json.loads(api_hope)
# 2> 断言
try:
assert api_hope == response
except Exception as e:
self.log.error('实际结果与预期结果不符！')
assert False, '实际结果与预期结果不符！'
else:
pass
# 3.用例不执行
elif api_active == 'NO':
self.log.info(list)
self.log.info('未执行测试用例编号 : {0} | 名称 : {1}\n'.format(
api_no, api_name))
pass
class API_REQUEST(Login):
def __init__(self, sheet_name):
Handle.__init__(self)
# 1.sheet_name
self.sheet_name = sheet_name
# 2.token
self.token = self.get_token()
self.token1 = self.get_token1()
# 3. 创建请求对象
self.R = RequestForHttp()
# 4.获取excel中行数据
self.excel = Excel(xls='data_api.xls', sheet_name=self.sheet_name)
self.data = self.excel.get_row_data(sheet_name=self.sheet_name)
# 5.关联字典
# 关联字典
self.correlationDict = {}
self.checkDict = {}
# 其中内置了四个参数，分别是：
# ${token}（token令牌值）
# ${randomTel}（随机手机号码）
# ${timestamp}（当前时间戳）
# ${session}（session#id，默认为None）
# ${hashPassword}（hash加密密码，明文123456）
self.correlationDict['${self.token}'] = self.token
self.correlationDict['${self.token1}'] = self.token1
self.correlationDict['${space_name}'] = 'api测试'
def print_log(self, api_no, api_name, api_describe, api_url, api_function,
api_headers, api_data, api_check, api_status, api_hope,
response):
'''
打印日志模块
:param api_no : 接口编号
:param api_name : 接口名称
:param api_describe : 接口描述
:param api_url : 接口地址
:param api_function : 接口方法
:param api_headers : 接口头部
:param api_data : 接口数据
:param api_check : 接口检查
:param api_hope : 接口预期
:param response : 接口返回
:return:
'''
self.log.info('1. 接口编号 : {0}'.format(api_no))
self.log.info('2. 接口名称 : {0}'.format(api_name))
self.log.info('3. 接口描述 : {0}'.format(api_describe))
self.log.info('4. 接口路由 : {0}'.format(api_url))
self.log.info('5. 接口方式 : {0}'.format(api_function))
self.log.info('6. 接口头部 : {0}'.format(api_headers))
self.log.info('7. 接口数据 : {0}'.format(api_data))
self.log.info('8. 接口检查 : {0}'.format(api_check))
self.log.info('9. 预期状态 ：{0}'.format(api_status))
self.log.info('10.接口预期 : {0}'.format(api_hope))
if api_status == 204:
self.log.info('11.接口返回 : {0}'.format(response[1]))
else:
self.log.info('11.接口返回 : {0}'.format(response[1]))
def api_method(self, method, api_url, data, api_headers):
'''
请求方式选择器
:param method : 请求方式
:param api_url : 接口路由
:param data : 请求数据
:param api_headers : 请求头
:return:
'''
if method == 'GET':
response = self.R.get_function(api_url, data)
return response
elif method == 'POST':
response = self.R.post_function(api_url, data, api_headers)
return response
elif method == 'DELETE':
response = self.R.delete_function(api_url, data)
return response
elif method == 'PUT':
response = self.R.put_function(api_url, data)
return response
else:
pass
'''
通用的接口请求方法,返回接口的response值
'''
def api_requests(self, api_no, api_name, api_describe, api_url,
api_function, api_headers, api_data, api_check, api_hope,
api_status, api_correlation, api_messages):
'''
公用请求方法
:param api_no : 接口编号
:param api_name : 接口名称
:param api_describe : 接口描述
:param api_url : 接口地址
:param api_function : 接口方法
:param api_headers : 接口头部
:param api_data : 接口数据
:param api_check : 接口检查
:param api_hope : 接口预期
:return : 接口返回 response[0] - 状态码 | response[1] - 返回值
'''
# 0 解析请求头，如果为json类型，将str类型的headers转换成字典类型
if api_headers == "{'Content-Type':'application/json'}":
# 1）将header转换成字典格式
api_headers = eval(api_headers)
# 2）直接将api_data转换成json格式
self.data = self.analysis_data(api_data)
self.data = json.dumps(self.data)
# 3）解析url
api_url = self.analysis_url(api_url)
# 1 如果api_headers为空
if api_headers == '':
# 1.解析data 和 url ———— 将data转为字典格式
try:
# 1.1解析测试数据
self.data = self.analysis_data(api_data)
# 1.2 解析url
api_url = self.analysis_url(api_url)
except Exception as e:
# 1.1 将请求数据转换成字典
self.data = api_data
self.data = eval(self.data)
# 1.2 解析url
api_url = self.analysis_url(api_url)
self.log.error(e)
# 2. 发送请求
# 2.1 发送请求
response = self.api_method(method=api_function,
api_url=api_url,
data=self.data,
api_headers=api_headers)
# 2.2 打印日志
# 2.1 > 如果状态码不为204
if api_status != 204:
# 3. 打印日志
self.print_log(api_no, api_name, api_describe, api_url,
api_function, api_headers, self.data, api_check,
api_hope, api_status, response)
# 4.解析返回值
status_code = response[0] # 状态码
response1 = json.loads(response[1]) # 解析返回值
self.analysis_response(api_no, api_name, api_correlation,
response1)
# 5.解析关联消息
self.analysis_messages(api_no, api_name, api_messages)
return status_code, response1
# 2.2 > 如果状态码为204
elif api_status == 204:
# 3.解析返回值
status_code = response # 状态码
response1 = ''
response = [status_code, response1]
# 4. 打印日志
self.print_log(api_no, api_name, api_describe, api_url,
api_function, api_headers, self.data, api_check,
api_hope, api_status, response)
# 5.解析关联消息
self.analysis_messages(api_no, api_name, api_messages)
# return status_code, response1
return response
# # 2. 发送请求
# # 2.1 > 如果状态码不为204
# if api_status != 204:
#
# # 2. 发送请求
# response = self.api_method(method=api_function, api_url=api_url, data=data, api_headers=api_headers)
#
# # 3. 打印日志
# self.print_log(api_no, api_name, api_describe, api_url, api_function, api_headers,
# data, api_check, api_hope, api_status, response)
#
# # 4.解析返回值
# status_code = response[0] # 状态码
# response1 = json.loads(response[1]) # 解析返回值
# self.analysis_response(api_no, api_name, api_correlation, response1)
#
# # 5.解析关联消息
# self.analysis_messages(api_no, api_name, api_messages)
#
# return status_code, response1
#
# # 2.2 > 如果状态码为204，返回结果为【no content】
# elif api_status == 204:
#
# # 2.发送请求
# response = self.api_method(method=api_function, api_url=api_url, data=data, api_headers=api_headers)
#
# # 3.解析返回值
# status_code = response # 状态码
# response1 = ''
# response = [status_code, response1]
#
# # 4. 打印日志
# self.print_log(api_no, api_name, api_describe, api_url, api_function, api_headers,
# data, api_check, api_hope, api_status, response)
#
# # 5.解析关联消息
# self.analysis_messages(api_no, api_name, api_messages)
#
# return status_code, response1
'''
用于解析返回值中的数据和请求数据中的关联项
'''
# 用于解析请求地址(api_data)
def analysis_url(self, api_url):
'''
用于解析url地址
:param api_url : 接口路由
:return:
'''
# 1.替换api_data中的关联项
for k in self.correlationDict:
if (api_url.find(k)) > 0:
# 此处将id team_id等参数获取到后转换成str类型
api_url = api_url.replace(k, str(self.correlationDict[k]))
return api_url
# 用于解析请求数据(api_data)
def analysis_data(self, api_data):
'''
用于解析关联数据，将需要关联的字段存到关联字典中
:param api_data : 接口请求数据
:return:
'''
# 1.请求数据：字符串转字典
dic_api_data = eval(api_data)
# 2.循环遍历测试数据
for k in dict(dic_api_data):
for key in self.correlationDict:
if dic_api_data[k] == key:
dic_api_data[k] = self.correlationDict[key]
return dic_api_data
# 用于解析返回值(response)
def analysis_response(self, api_no, api_name, correlation, response):
'''
用于解析返回值中的数据，将这些数据存入关联字典中以供使用
:param response : 接口返回值
:return:
'''
# 如果关联数据不为空
if correlation != '':
# 1.处理关联数据(存到列表中)
correlation = correlation.replace('\n', '').replace('\r',
'').split(';')
# 2.分解关联数据
for j in range(len(correlation)):
correlation = correlation[j].split('=')
# 3.判断处理后的关联列表长度为2时
if len(correlation) == 2:
if correlation[1] == '' or not re.search(
r'^\[', correlation[1]) or not re.search(
r'\]$', correlation[1]):
self.log.error(
api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Correlation]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
value = response
# 5.继续处理correlation
a = correlation[1][1:-1].split('][')
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
self.correlationDict[correlation[0]] = value
return self.correlationDict
# 用于解析检查点
def analysis_check(self, api_no, api_name, api_check, response):
'''
用于检查点的校验
:param response : 接口返回值
:return:
'''
# 标志符
flag = ''
# print("flag标志 = ", flag)
# 如果检查数据不为空
if api_check != '':
# 1.处理关联数据(存到列表中)
api_check = api_check.replace('\n', '').replace('\r',
'').split(';')
# print('api_check = ',api_check)
# 2.分解关联数据
for j in range(len(api_check)):
# 判断是否为'='关系
if '=' in api_check[j]:
# print("= 存在于api_check中")
# 如果 '#len#' 存在
if '#len#' in api_check[j]:
# print('去除指定的 #len# 字符串 ：', api_check[j].strip('#len#'))
# param = api_check[j].replace('#len#', '').split('=')
flag = '#len#'
# print("1.flag 等于#len# ：", flag)
# 如果 '#len#'不存在
elif '#len#' not in api_check[j]:
param = api_check[j].split('=')
# print('没进入 #len# 的param = ', param)
flag = '='
# 判断是否为'<>'关系
elif '<>' in api_check[j]:
param = api_check[j].split('<>')
flag = '<>'
# print("4. flag = <>:", flag)
# 3.判断处理后的关联列表长度为2时
if len(param) == 2:
if param[1] == '' or not re.search(
r'^\[', param[1]) or not re.search(
r'\]$', param[1]):
self.log.error(api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Check]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
value = response
# 5.继续处理api_check
a = param[1][1:-1].split('][')
# print('a = ',a)
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
print('#value# = ', value)
# 替换检查点中的关联数据
print('self.correlationDict = ', self.correlationDict)
for k in self.correlationDict:
if param[0] == k:
print('param[0] = ', param[0])
param[0] = self.correlationDict[k]
print('k = ', k)
print(param[0])
try:
print("----------进入检查点数据校验-------------")
print("flag = ", flag)
# 检查点数据校验
# '='关系断言
if flag == '=':
print('等于')
print('进入等于阶段后的---->param[0] = ', param[0])
print('进入等于阶段后的---->type(param[0]) 值 = ',
type(param[0]))
print('进入等于阶段后的---->value 值 = ', value)
print('进入等于阶段后的---->type(value) 值 = ', type(value))
# 如果返回值解析结果value值是数值，先将check中解析出来的param[0]的值转为int再断言
if type(value) == int:
print('进入if')
assert int(param[0]) == value
print('true', value)
# 20180410 10:36加入
# return [True, value]
# 将value值中的True或False的类型转换成str类型，再与param[0]断言
# 先判断传进来的parma[0]的类型是否为str类型，如果是才能和'True'/'False'比较
elif param[0] == 'True' or param[0] == 'False':
print('进入elif')
value1 = str(value)
assert param[0] == value1
print('true', value1)
# 20180410 10:36加入
# return [True, value]
# 无需转换时，直接比较检查点
else:
print('进入else')
print('param[0] = ', param[0])
print('value = ', value)
assert param[0] == value
print('true', value)
# 20180410 10:36加入
# return [True, value]
# '<>'关系断言
if flag == '<>':
print('不等于')
print('进入不等于阶段后的---->param[0] = ', param[0])
print('进入不等于阶段后的---->type(param[0]) 值 = ',
type(param[0]))
print('进入不等于阶段后的---->value 值 = ', value)
print('进入不等于阶段后的---->type(value) 值 = ', type(value))
# 如果返回值解析结果value值是数值，先将check中解析出来的param[0]的值转为int再断言
if type(value) == int:
print('进入if')
assert int(param[0]) != value
print('true', value)
# 20180410 10:36加入
# return [True, value]
# 将value值中的True或False的类型转换成str类型，再与param[0]断言
# 先判断传进来的parma[0]的类型是否为str类型，如果是才能和'True'/'False'比较
elif param[0] == 'True' or param[0] == 'False':
print('进入elif')
value1 = str(value)
assert param[0] != value1
print('true', value1)
# 20180410 10:36加入
# return [True, value]
# 无需转换时，直接比较检查点
else:
print('进入else')
print('param[0] = ', param[0])
print('value = ', value)
assert param[0] != value
print('true', value)
# 20180410 10:36加入
# return [True, value]
# # 先将value值中的True或False的类型转换成str类型，再与param[0]断言
# if param[0] in 'True' or 'False':
# value = str(value)
# print('true',value)
# assert param[0] != value
# # 20180410 10:36加入
# # return [True, value]
# # 如果返回数据为int型，比较时将excel中的数据先转换成整型数据
# elif type(value) == int:
# # elif isinstance(value,int):
# # print('进入elif')
# print('true',value)
# assert int(param[0]) != value
# # 20180410 10:36加入
# # return [True, value]
# # 无需转换时，直接比较检查点
# else:
# # print('进入else')
# print('true',value)
# assert param[0] != value
# # 20180410 10:36加入
# # return [True, value]
# '#len#'关系断言
if flag == '#len#':
print('进入#len#')
print('true', value)
assert len(value) == int(param[0])
# 20180410 10:36加入
# return [True, value]
except Exception as e:
print('e = ', e)
print('进入exception')
print('false', value)
return [False, value]
return [True, value]
# 获取leancloud系统消息记录
def get_Messages_from_leancloud(self):
import requests
url = "https://3bxid9fg.api.lncld.net/1.1/rtm/messages/history"
headers = {
'X-LC-Id': "3BXiD9Fga5RtswdyrJSFQ3h3-gzGzoHsz",
'X-LC-Sign':
"7396816f73bdbcf70281b09dc2c1b3b9,1517046641139,master",
}
# 1.发送请求
with requests.Session() as s:
response = s.get(url, headers=headers)
# 2.解析返回内容
res = response.text
# 3.转为字典
dict_r = json.loads(res)
# 转为json,并格式化输出
json_r = json.dumps(dict_r,
sort_keys=True,
ensure_ascii=False,
indent=4,
separators=(',', ': '))
return json_r
# 获取发送给某个用户的(忽略发送着的身份【system】|【user】)最新一条消息的【data】数据
def get_first_message(self, to_who):
# 1.调用消息记录模块,返回消息记录列表
re1 = self.get_Messages_from_leancloud()
re1 = json.loads(re1)
# 2.循环存消息
messages = []
for i in re1:
if i['to'] == to_who:
messages.append(i)
else:
pass
message_1 = messages[0]
# 3.解析第一条数据
dict1 = message_1['data']
data = dict1 = json.loads(dict1)
# 4.直接取出id
# dict1 = dict1['_lcattrs']['id']
# 5.格式化输出
# message_1 = json.dumps(message_1, sort_keys=True, ensure_ascii=False, indent=4, separators=(',', ': '))
# print(message_1)
# print(dict1)
# 6.返回message_1,类型为字典
return data
# 解析发给某个用户的最新一条消息的关联数据
def analysis_messages(self, api_no, api_name, correlation):
'''
用于解析返回值中的数据，将这些数据存入关联字典中以供使用
:return:
'''
# 如果关联数据不为空
if correlation != '':
# 1.处理关联数据(存到列表中)
correlation = correlation.replace('\n', '').replace('\r',
'').split(';')
# 2.分解关联数据
for j in range(len(correlation)):
correlation = correlation[j].split('=')
# 3.判断处理后的关联列表长度为2时
if len(correlation) == 2:
if correlation[1] == '' or not re.search(
r'^\[', correlation[1]) or not re.search(
r'\]$', correlation[1]):
self.log.error(
api_no + ' ' + api_name +
' 关联参数设置有误，请检查[Correlation]字段参数格式是否正确！！！')
continue
# 4.返回结果赋值
'''
临时方案，此时推送给的用户id是写死的，token1的用户
'''
value = self.get_first_message(
to_who='d66dcb63-107f-4d30-a632-d97882b7465f')
# 5.继续处理correlation
a = correlation[1][1:-1].split('][')
# 6.循环遍历列表的键
for key in a:
try:
temp = value[int(key)]
except:
try:
temp = value[key]
except:
break
value = temp
self.correlationDict[correlation[0]] = value
return self.correlationDict