예제 #1
0
    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测试'
예제 #2
0
    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')
예제 #3
0
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]))
예제 #4
0
    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测试'
        }
예제 #5
0
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
예제 #6
0
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
예제 #7
0
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
예제 #8
0
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