コード例 #1
0
    def extrator(self,extrator,response_to_check=''):
        if type(extrator) == type({}):  # 获取键值
            #  获取list方式标识的key,value层级值
            dict_level_list = other_tools.get_dict_level_list(extrator)
            other_tools.set_dict_level_list([])

            logger.info('要提取的字典key,value层级为:%s' % dict_level_list)

            if type(response_to_check) == type(''): # 字符串类型的字典、json串
                try:
                    response_to_check = json.loads(response_to_check) # //转字符串为json
                except Exception as e:
                    logger.error('转换服务器返回内容为字典失败:%s' % e)
                    return []

            if type(response_to_check) != type({}):
                logger.error('服务器返回内容不为字典、字符串类型的字典')
                return []

            value_get = other_tools.find_dict_last_leve_value(dict_level_list, response_to_check)
            logger.info('找到的对应字典层级的key的值为:%s' % value_get)
            other_tools.set_key_index(0)

            return value_get
        elif type(extrator) == type(''): # 获取正则表达式匹配的内容
            if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                response_to_check = str(response_to_check)
            elif type(response_to_check) != type(''):
                logger.error('服务器返回内容不为字符串类型')
                return []
            result = re.findall(extrator, response_to_check)
            return  result
        else:
            logger.error('提取器不为字典或者字符串类型的正则表达式')
            return []
コード例 #2
0
    def assert_result(self, response_to_check):
        '''
        执行预期结果
        :param response_to_check: 服务器返回的响应
        :return: 用户没有设置匹配规则,返回程序
        '''
        if self.expected_result != '':
            if re.findall('匹配规则', str(self.expected_result)) == []:
                logger.info('用户没有设置匹配规则,返回程序')
                self.assertEqual(1, 1, msg='用户没有设置匹配规则')
                return

        if self.expected_result != '':
            if self.expected_result['匹配规则'] == '包含成员':
                if type(response_to_check) not in [type(''), type([]), type(()), type(set()), type({})]:
                    logger.error('服务器返回内容为不可迭代对象')
                    self.assertEqual(1, 0, msg='服务器返回内容为不可迭代对象')

                # 遍历条件列表, 形如 "条件":[{"模式":"\"success\"", "消息":"创建储值卡支付订单失败,返回json串不包含key - success"},{"模式":"\"attach\"", "消息":"创建储值卡支付订单失败,返回json串不包含key - attach"}]
                for item in self.expected_result['条件']:
                    member = item['模式']
                    logger.info('要匹配的模式(成员)为:%s' % member)
                    self.assertIn(member, response_to_check, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '不包含成员':
                if type(response_to_check) not in [type(''), type([]), type(()), type(set()), type({})]:
                    logger.error('服务器返回内容为不可迭代对象')
                    self.assertEqual(1, 0, msg='服务器返回内容为不可迭代对象')

                # 遍历条件列表,形如 "条件":[{"模式":"\"success\"", "消息":"创建储值卡支付订单失败,返回json串包含key - success"},{"模式":"\"attach\"", "消息":"创建储值卡支付订单失败,返回json串包含key - attach"}]
                for item in self.expected_result['条件']:
                    member = item['模式']
                    logger.info('要匹配的模式(成员)为:%s' % member)
                    self.assertNotIn(member, response_to_check, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '包含字符串':
                if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如:"条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']
                    logger.info('要匹配的模式(子字符串)为:%s' % pattern_str)
                    self.assertIn(pattern_str, response_to_check, item['消息'])

            elif self.expected_result['匹配规则'] == '不包含字符串':
                if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如:"条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']
                    logger.info('要匹配的模式(子字符串)为:%s' % pattern_str)
                    self.assertNotIn(pattern_str, response_to_check, item['消息'])

            elif self.expected_result['匹配规则'] == '键值相等':
                if type(response_to_check) == type(''):  # 字符串类型的字典、json串
                    try:
                        response_to_check = json.loads(response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.error('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')

                if type(response_to_check) == type([]):  # 格式[{}]的json串
                    try:
                        response_to_check = response_to_check[0]
                        response_to_check = json.loads(response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.error('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')

                if type(response_to_check) != type({}):
                    logger.error('服务器返回内容不为字典、字符串类型的字典')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字典、字符串类型的字典')

                # 遍历条件列表, 形如:"条件":[{"模式":{"success":true}, "消息":"创建储值卡支付订单失败,success不为True"},{"模式":{"success":false}, "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_dic = item['模式']
                    # 获取list方式标识的key,value层级值
                    dict_level_list = other_tools.get_dict_level_list(pattern_dic)
                    other_tools.set_dict_level_list([])
                    logger.info('要匹配的字典key,value层级为:%s' % dict_level_list)

                    last_value = other_tools.find_dict_last_leve_value(dict_level_list, response_to_check)
                    logger.info('找到的对应字典层级的最后值为:%s' % last_value)
                    other_tools.set_key_index(0)

                    # 比较同层级,相同key对应的value值
                    self.assertEqual(dict_level_list[len(dict_level_list) - 1], last_value, item['消息'])

            elif self.expected_result['匹配规则'] == '匹配正则表达式':
                if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如( "条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']

                    logger.info('要匹配的模式(正则表达式)为:%s' % pattern_str)
                    self.assertRegex(response_to_check, pattern_str, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '不匹配正则表达式':
                if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表,形如  "条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']

                    logger.info('要匹配的模式(正则表达式)为:%s' % pattern_str)
                    self.assertNotRegex(response_to_check, pattern_str, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配字典':
                if type(response_to_check) == type(''):  # 字符串类型的字典、json串
                    try:
                        response_to_check = json.loads(response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.info('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')
                elif type(response_to_check) != type({}):
                    logger.error('服务器返回内容不为字典')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字典')

                # 遍历条件列表 "条件":[{"模式":{"success":true}, "消息":"创建储值卡支付订单失败,返回结果和字典模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_dic = item['模式']

                    logger.info('要匹配的模式(字典)为:%s' % pattern_dic)
                    self.assertDictEqual(response_to_check, pattern_dic, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配列表':
                if type(response_to_check) == type(''):  # 字符串类型的列表
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.info('转换服务器返回内容为列表失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为列表失败')

                if type(response_to_check) != type([]):
                    logger.info('服务器返回内容不为列表或列表的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为列表或列表的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_list = eval(item['模式'])

                    logger.info('要匹配的模式(列表)为:%s' % pattern_list)
                    self.assertListEqual(response_to_check, pattern_list, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配集合':
                if type(response_to_check) == type(''):  # 字符串类型的集合
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.error('转换服务器返回内容为集合失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为集合失败')

                if type(response_to_check) != type(set()):
                    logger.error('服务器返回内容不为集合或集合的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为集合或集合的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_set = eval(item['模式'])

                    logger.info('要匹配的模式(集合)为:%s' % pattern_set)
                    self.assertSetEqual(response_to_check, pattern_set, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配元组':
                if type(response_to_check) == type(''):  # 字符串类型的元组
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.error('转换服务器返回内容为元组失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为元组失败')

                if type(response_to_check) != type(()):
                    logger.error('服务器返回内容不为元组或元组的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为元组或元组的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_tuple = eval(item['模式'])

                    logger.info('要匹配的模式(元组)为:%s' % str(pattern_tuple))
                    self.assertTupleEqual(response_to_check, pattern_tuple, msg=item['消息'])

            elif (self.expected_result['匹配规则']).lower() == 'xpath断言':
                try:
                    root = ET.fromstring(response_to_check)
                except ET.ParseError as e:
                    self.assertEqual(1, 0, '%s' % e)

                for item in self.expected_result['条件']:
                    pattern_dic = item['模式']
                    logger.info('要检测的模式为:%s' % pattern_dic)
                    for key in pattern_dic.keys():
                        if key == '.':
                            content_to_check = root.text
                            expect_value = pattern_dic[key]
                        else:
                            xmlnsnamespace_dic = {}  # 存放 前缀:对应uri
                            logger.info('正在获取xmlns定义')
                            match_result_list = re.findall('xmlns[^:]?=(.+?)[ |\>|\\\>]', response_to_check,
                                                           re.MULTILINE)
                            if match_result_list:
                                xmlns = match_result_list[len(match_result_list) - 1]
                                xmlns = xmlns.strip(' ')
                                xmlns = '{' + xmlns + '}'
                                logger.info('xmlns定义为:%s' % xmlns)
                                xmlnsnamespace_dic['xmlns'] = xmlns

                            logger.info('正在获取"xmlns:xxx名称空间定义')
                            match_result_list = re.findall('xmlns:(.+?)=(.+?)[ |>]', response_to_check)
                            for ns in match_result_list:
                                xmlnsnamespace_dic[ns[0]] = '{' + ns[1] + '}'

                            logger.info("最后获取的prefix:uri为:%s" % xmlnsnamespace_dic)

                            logger.info('正在转换元素结点前缀')
                            key_copy = key
                            for dic_key in xmlnsnamespace_dic.keys():
                                namespace = dic_key + ':'
                                if namespace in key:
                                    uri = xmlnsnamespace_dic[dic_key]
                                    key = key.replace(namespace, uri)
                                    key = key.replace('"', '')

                            logger.info('转换后用于查找元素的xpath:%s' % key)
                            try:
                                elements_list = root.findall(key)
                            except Exception as e:
                                logger.error('查找元素出错:%s' % e)
                                self.assertEqual(1, 0, msg='%s' % e)
                            logger.info('查找到的元素为:%s' % elements_list)

                            logger.info('正在进行断言')
                            if elements_list:
                                content_to_check = elements_list[0].text
                            else:
                                content_to_check = ''
                            expect_value = pattern_dic[key_copy]
                        logger.info('从服务器返回的提取的待检查数据的类型:%s' % type(content_to_check))
                        logger.info('用户期望值的数据类型:%s' % type(expect_value))
                        self.assertEqual(content_to_check, expect_value, msg=item['消息'])
コード例 #3
0
    def extrator(self, extrator_type, extrator, response_to_check=''):
        if extrator_type == 'dic':  # 获取键值
            #  获取list方式标识的key,value层级值
            dict_level_list = other_tools.get_dict_level_list(extrator)
            other_tools.set_dict_level_list([])

            logger.info('要提取的字典key,value层级为:%s' % dict_level_list)

            if type(response_to_check) == type(''):  # 字符串类型的字典、json串
                try:
                    response_to_check = json.loads(response_to_check)  # //转字符串为json
                except Exception as e:
                    logger.error('转换服务器返回内容为字典失败:%s' % e)
                    return ''

            if type(response_to_check) != type({}):
                logger.error('服务器返回内容不为字典、字符串类型的字典')
                return ''

            value_get = other_tools.find_dict_last_leve_value(dict_level_list, response_to_check)
            logger.info('找到的对应字典层级的key的值为:%s' % value_get)
            other_tools.set_key_index(0)

            return value_get
        elif extrator_type == 're':  # 获取正则表达式匹配的内容
            if type(response_to_check) in [type({}), type(set()), type(()), type([]), type(1), type(0.01)]:
                response_to_check = str(response_to_check)
            elif type(response_to_check) != type(''):
                logger.error('服务器返回内容不为字符串类型')
                return []
            result = re.findall(extrator, response_to_check)
            return result
        elif extrator_type == 'xpath':
            try:
                root = ET.fromstring(response_to_check)
            except ET.ParseError as e:
                logger.error('%s' % e)
                return ''

            logger.info('xpath表达式为:%s' % extrator)
            if extrator == '.':
                value_get = root.text
            else:
                xmlnsnamespace_dic = {}  # 存放 前缀:对应uri
                logger.info('正在获取xmlns定义')
                match_result_list = re.findall('xmlns[^:]?=(.+?)[ |\>|\\\>]', response_to_check, re.MULTILINE)
                if match_result_list:
                    xmlns = match_result_list[len(match_result_list) - 1]
                    xmlns = xmlns.lstrip(' ')
                    xmlns = '{' + xmlns + '}'
                    logger.info('xmlns定义为:%s' % xmlns)
                    xmlnsnamespace_dic['xmlns'] = xmlns

                    logger.info('正在获取"xmlns:xxx名称空间定义')
                    match_result_list = re.findall('xmlns:(.+?)=(.+?)[ |>]', response_to_check)
                    for ns in match_result_list:
                        xmlnsnamespace_dic[ns[0]] = '{' + ns[1] + '}'

                    logger.info("最后获取的prefix:uri为:%s" % xmlnsnamespace_dic)

                    logger.info('正在转换元素结点前缀')
                    for dic_key in xmlnsnamespace_dic.keys():
                        namespace = dic_key + ':'
                        if namespace in extrator:
                            uri = xmlnsnamespace_dic[dic_key]
                            extrator = extrator.replace(namespace, uri)
                            extrator = extrator.replace('"', '')

                    logger.info('转换后用于查找元素的xpath:%s' % extrator)

                    try:
                        elements_list = root.findall(extrator)
                    except Exception as e:
                        logger.error('查找xpath元素出错:%s' % e)
                        value_get = ''
                    logger.info('查找到的元素为:%s' % elements_list)
                    if elements_list:
                        value_get = elements_list[0].text
                    else:
                        value_get = ''
            return value_get
        else:
            logger.error('提取器填写错误')
            return None
コード例 #4
0
    def assert_result(self, response_to_check):
        if self.expected_result != '':
            if self.expected_result['匹配规则'] == '包含成员':
                if type(response_to_check) not in [
                        type(''),
                        type([]),
                        type(()),
                        type(set()),
                        type({})
                ]:
                    logger.error('服务器返回内容为不可迭代对象')
                    self.assertEqual(1, 0, msg='服务器返回内容为不可迭代对象')

                # 遍历条件列表, 形如 "条件":[{"模式":"\"success\"", "消息":"创建储值卡支付订单失败,返回json串不包含key - success"},{"模式":"\"attach\"", "消息":"创建储值卡支付订单失败,返回json串不包含key - attach"}]
                for item in self.expected_result['条件']:
                    member = item['模式']
                    logger.info('要匹配的模式(成员)为:%s' % member)
                    self.assertIn(member, response_to_check, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '不包含成员':
                if type(response_to_check) not in [
                        type(''),
                        type([]),
                        type(()),
                        type(set()),
                        type({})
                ]:
                    logger.error('服务器返回内容为不可迭代对象')
                    self.assertEqual(1, 0, msg='服务器返回内容为不可迭代对象')

                # 遍历条件列表,形如 "条件":[{"模式":"\"success\"", "消息":"创建储值卡支付订单失败,返回json串包含key - success"},{"模式":"\"attach\"", "消息":"创建储值卡支付订单失败,返回json串包含key - attach"}]
                for item in self.expected_result['条件']:
                    member = item['模式']
                    logger.info('要匹配的模式(成员)为:%s' % member)
                    self.assertNotIn(member, response_to_check, msg=item['消息'])

            elif self.expected_result['匹配规则'] == '包含字符串':
                if type(response_to_check) in [
                        type({}),
                        type(set()),
                        type(()),
                        type([]),
                        type(1),
                        type(0.01)
                ]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如:"条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']
                    logger.info('要匹配的模式(子字符串)为:%s' % pattern_str)
                    self.assertIn(pattern_str, response_to_check, item['消息'])

            elif self.expected_result['匹配规则'] == '不包含字符串':
                if type(response_to_check) in [
                        type({}),
                        type(set()),
                        type(()),
                        type([]),
                        type(1),
                        type(0.01)
                ]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如:"条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']
                    logger.info('要匹配的模式(子字符串)为:%s' % pattern_str)
                    self.assertNotIn(pattern_str, response_to_check,
                                     item['消息'])

            elif self.expected_result['匹配规则'] == '键值相等':
                if type(response_to_check) == type(''):  # 字符串类型的字典、json串
                    try:
                        response_to_check = json.loads(
                            response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.error('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')

                if type(response_to_check) == type([]):  # 格式[{}]的json串
                    try:
                        response_to_check = response_to_check[0]
                        response_to_check = json.loads(
                            response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.error('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')

                if type(response_to_check) != type({}):
                    logger.error('服务器返回内容不为字典、字符串类型的字典')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字典、字符串类型的字典')

                # 遍历条件列表, 形如:"条件":[{"模式":{"success":true}, "消息":"创建储值卡支付订单失败,success不为True"},{"模式":{"success":false}, "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_dic = item['模式']
                    # 获取list方式标识的key,value层级值
                    dict_level_list = other_tools.get_dict_level_list(
                        pattern_dic)
                    other_tools.set_dict_level_list([])
                    logger.info('要匹配的字典key,value层级为:%s' % dict_level_list)

                    last_value = other_tools.find_dict_last_leve_value(
                        dict_level_list, response_to_check)
                    logger.info('找到的对应字典层级的最后值为:%s' % last_value)
                    other_tools.set_key_index(0)

                    # 比较同层级,相同key对应的value值
                    self.assertEqual(dict_level_list[len(dict_level_list) - 1],
                                     last_value, item['消息'])

            elif self.expected_result['匹配规则'] == '匹配正则表达式':
                if type(response_to_check) in [
                        type({}),
                        type(set()),
                        type(()),
                        type([]),
                        type(1),
                        type(0.01)
                ]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表, 形如( "条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success不为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success不为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']

                    logger.info('要匹配的模式(正则表达式)为:%s' % pattern_str)
                    self.assertRegex(response_to_check,
                                     pattern_str,
                                     msg=item['消息'])

            elif self.expected_result['匹配规则'] == '不匹配正则表达式':
                if type(response_to_check) in [
                        type({}),
                        type(set()),
                        type(()),
                        type([]),
                        type(1),
                        type(0.01)
                ]:
                    response_to_check = str(response_to_check)
                elif type(response_to_check) != type(''):
                    logger.error('服务器返回内容不为字符串类型')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字符串类型')

                # 遍历条件列表,形如  "条件":[{"模式":"\"success\":true", "消息":"创建储值卡支付订单失败,success为True"},{"模式":"\"success\":false", "消息":"创建储值卡支付订单失败,success为false"}]
                for item in self.expected_result['条件']:
                    pattern_str = item['模式']

                    logger.info('要匹配的模式(正则表达式)为:%s' % pattern_str)
                    self.assertNotRegex(response_to_check,
                                        pattern_str,
                                        msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配字典':
                if type(response_to_check) == type(''):  # 字符串类型的字典、json串
                    try:
                        response_to_check = json.loads(
                            response_to_check)  # //转字符串为json
                    except Exception as e:
                        logger.info('转换服务器返回内容为字典失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为字典失败')
                elif type(response_to_check) != type({}):
                    logger.error('服务器返回内容不为字典')
                    self.assertEqual(1, 0, msg='服务器返回内容不为字典')

                # 遍历条件列表 "条件":[{"模式":{"success":true}, "消息":"创建储值卡支付订单失败,返回结果和字典模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_dic = item['模式']

                    logger.info('要匹配的模式(字典)为:%s' % pattern_dic)
                    self.assertDictEqual(response_to_check,
                                         pattern_dic,
                                         msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配列表':
                if type(response_to_check) == type(''):  # 字符串类型的列表
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.info('转换服务器返回内容为列表失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为列表失败')

                if type(response_to_check) != type([]):
                    logger.info('服务器返回内容不为列表或列表的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为列表或列表的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_list = eval(item['模式'])

                    logger.info('要匹配的模式(列表)为:%s' % pattern_list)
                    self.assertListEqual(response_to_check,
                                         pattern_list,
                                         msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配集合':
                if type(response_to_check) == type(''):  # 字符串类型的集合
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.error('转换服务器返回内容为集合失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为集合失败')

                if type(response_to_check) != type(set()):
                    logger.error('服务器返回内容不为集合或集合的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为集合或集合的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_set = eval(item['模式'])

                    logger.info('要匹配的模式(集合)为:%s' % pattern_set)
                    self.assertSetEqual(response_to_check,
                                        pattern_set,
                                        msg=item['消息'])

            elif self.expected_result['匹配规则'] == '完全匹配元组':
                if type(response_to_check) == type(''):  # 字符串类型的元组
                    try:
                        response_to_check = eval(response_to_check)
                    except Exception as e:
                        logger.error('转换服务器返回内容为元组失败')
                        self.assertEqual(1, 0, msg='转换服务器返回内容为元组失败')

                if type(response_to_check) != type(()):
                    logger.error('服务器返回内容不为元组或元组的字符串表示')
                    self.assertEqual(1, 0, msg='服务器返回内容不为元组或元组的字符串表示')

                # 遍历条件列表,形如 "条件":[{"模式":"[\"success\",\"shouke\",2016]", "消息":"创建储值卡支付订单失败,返回结果和列表模式不匹配"}]
                for item in self.expected_result['条件']:
                    pattern_tuple = eval(item['模式'])

                    logger.info('要匹配的模式(元组)为:%s' % str(pattern_tuple))
                    self.assertTupleEqual(response_to_check,
                                          pattern_tuple,
                                          msg=item['消息'])