Beispiel #1
0
    def assert_deal(self, resp):
        check_point_list = self.check_point.split(",")
        check_result_list = []
        for i in check_point_list:                                  # check_point中可能需要多个校验的数据,所以要用逗号分隔符对字符串进行切片
            if 'code' in i or 'msg' in i:                           # 这里是判断是否是code和msg断言,前两种是正常和异常的code、msg断言
                if i in resp:
                    check_result_list.append(True)
                else:
                    check_result_list.append(False)
            else:                                                   # 这种情况是接口关键数据断言,校验具体返回的数据字段值
                # i必须是'{"openId":"$openId"}'这种格式,这里是对excel中的check_point格式进行了转换,excel中的格式必须是"${openId}>0"这种
                i_one = i.split("{")
                i_two = i_one[1].split("}")
                i_three = '$' + i_two[0]
                i_four = str({i_two[0]: i_three})
                request_data_last = CommonMethod.request_data_deal(i_four, resp)

                i_nine = i_two[1]
                i_ten = i_nine.split("\"")[0]
                if i_ten[1] != '=' and i_ten[1] != '<' and i_ten[1] != '>':
                    i_five = i_ten[0]                                                # 断言语句中的符号
                    i_six = i_ten[1:]                                                # 断言语句中的预期数据字段值
                else:
                    i_five = i_ten[:2]
                    i_six = i_ten[2:]

                i_seven = eval(request_data_last)
                i_eight = i_seven[i_two[0]]                                          # 从resp中拿出来的需要校验的实际数据字段值

                if i_five == '>':
                    check_result_list.append(str(i_eight) > str(i_six))
                elif i_five == '<':
                    check_result_list.append(str(i_eight) < str(i_six))
                elif i_five == '=':
                    check_result_list.append(str(i_eight) == str(i_six))
                elif i_five == '>=':
                    check_result_list.append(str(i_eight) >= str(i_six))
                elif i_five == '<=':
                    check_result_list.append(str(i_eight) <= str(i_six))
                elif i_five == '!=':
                    check_result_list.append(str(i_eight) != str(i_six))
                else:
                    LogPrint().info('--------断言语句中的比较符号有误,暂时只支持6种,请核对!---------')

        if False in check_result_list:
            self.assert_result = 'fail'
        else:
            self.assert_result = 'success'
Beispiel #2
0
    def run_test(self, result_id, test_case_list):
        check_list = []  # 用来核对某个用例是否已经执行过
        md = self.md
        conn = self.conn
        cur = self.cur
        # 该值是interface_test()函数处理完接口,并且断言完毕返回的结果,需要根据该结果更新test_result_data表的内容
        result_temp = ''
        for x in range(len(test_case_list)):
            # 循环所有的测试用例,先判断该用例是否已执行过,如果不在check_list中,则代表未执行过
            if int(test_case_list[x]['num']) not in check_list:
                # 未执行过的用例,再判断下该用例是否有关联的测试用例,如果测试用例的relevance_case字段值不为0,则代表有关联的用例
                if int(test_case_list[x]['relevance_case']) != 0:
                    LogPrint().info("----------开始调用第" +
                                    test_case_list[x]['num'] +
                                    "个测试用例的接口----------")
                    # 先去执行被关联的测试用例
                    for y in range(len(test_case_list)):
                        # 如果被关联的测试用例接口未执行过,那么就需要循环到被关联的接口,让它执行一次
                        if int(test_case_list[x]
                               ['relevance_case']) not in check_list:
                            # 如果已循环到该未执行过的被关联的接口
                            if int(test_case_list[y]['num']) == int(
                                    test_case_list[x]['relevance_case']):
                                # 先执行被关联的接口
                                result_two = self.run_test2(
                                    test_case_list[x]['relevance_case'],
                                    result_id, test_case_list)
                                LogPrint().info("----------继续调用第" +
                                                test_case_list[x]['num'] +
                                                "个测试用例的接口----------")
                                # 执行完毕后将该用例的编号存入到检查列表中,防止再次执行
                                check_list.append(
                                    int(test_case_list[x]['relevance_case']))

                                # 处理请求接口的数据,将被关联的接口数据赋值给请求的接口数据中
                                request_data_last = CommonMethod.request_data_deal(
                                    test_case_list[x]['request_data'],
                                    result_two)
                                ifd = InterfaceDeal(
                                    test_case_list[x]['num'],
                                    test_case_list[x]['api_purpose'],
                                    test_case_list[x]['request_url'],
                                    test_case_list[x]['request_method'],
                                    test_case_list[x]['request_data_type'],
                                    request_data_last,
                                    test_case_list[x]['check_point'],
                                    test_case_list[x]['test_describe'],
                                    test_case_list[x]['relevance_case'])
                                result_temp, response = ifd.interface_test()
                                check_list.append(int(
                                    test_case_list[x]['num']))

                            # 如果未循环到该关联的接口
                            else:
                                LogPrint().info('-----不是被关联的用例----')
                                continue

                        # 如果被关联的接口已执行过,那么就不需要用到这里的for y 的循环了
                        elif int(test_case_list[x]
                                 ['relevance_case']) in check_list:
                            # 如果请求的接口未执行过
                            if int(test_case_list[x]['num']) not in check_list:
                                LogPrint().info(
                                    "----------该用例所关联的接口已执行,继续调用第" +
                                    test_case_list[x]['num'] +
                                    "个测试用例的接口----------")
                                result_temp = 'execute yet'
                                sql_two = 'select response from test_case where case_id = %d order by create_time desc ' \
                                          'limit 1' % (int(test_case_list[x]['relevance_case']))
                                result = md.select_db(conn, cur, sql_two)
                                result_two = result[0][0]

                                # 处理请求接口的数据,将被关联的接口数据赋值给请求的接口数据中
                                request_data_last = CommonMethod.request_data_deal(
                                    test_case_list[x]['request_data'],
                                    result_two)
                                ifd = InterfaceDeal(
                                    test_case_list[x]['num'],
                                    test_case_list[x]['api_purpose'],
                                    test_case_list[x]['request_url'],
                                    test_case_list[x]['request_method'],
                                    test_case_list[x]['request_data_type'],
                                    request_data_last,
                                    test_case_list[x]['check_point'],
                                    test_case_list[x]['test_describe'],
                                    test_case_list[x]['relevance_case'])
                                result_temp2, response = ifd.interface_test()
                                check_list.append(int(
                                    test_case_list[x]['num']))

                                LogPrint().info(
                                    "----------------根据用例执行情况,开始更新测试结果表的相关数据----------------"
                                )
                                if result_temp2 == 'success':
                                    CommonMethod.sql_deal_two(
                                        md, conn, cur, 'success_num',
                                        result_id)
                                elif result_temp2 == 'fail':
                                    CommonMethod.sql_deal_two(
                                        md, conn, cur, 'fail_num', result_id)
                                elif result_temp2 == 'error':
                                    CommonMethod.sql_deal_two(
                                        md, conn, cur, 'error_num', result_id)

                            else:
                                LogPrint().info('-----该请求接口已执行----')

                # 未执行的用例,没有关联其他的测试用例,则直接调用interface_test函数,处理该接口即可
                else:
                    '''
                    这里接口没有关联其他接口,但是可能请求的参数中,会用到已单独封装的接口返回数据,或者其他随机函数的数据,所以需要将接口请求参数
                     另外再做处理,将未赋值的参数赋值,这里必须要有"data"数据,因为该函数还需要处理其他接口返回的值,这里为方便不修改代码先这样
                    '''
                    if test_case_list[x]['request_data_type'] == 'File':
                        request_data_last = CommonMethod.request_type_file(
                            test_case_list[x]['request_data'],
                            test_case_list[x]['num'])
                    else:
                        request_data_last = CommonMethod.request_data_deal(
                            test_case_list[x]['request_data'],
                            '{"code": 0, "msg": "操作成功!", "data": {}}')

                    ifd = InterfaceDeal(test_case_list[x]['num'],
                                        test_case_list[x]['api_purpose'],
                                        test_case_list[x]['request_url'],
                                        test_case_list[x]['request_method'],
                                        test_case_list[x]['request_data_type'],
                                        request_data_last,
                                        test_case_list[x]['check_point'],
                                        test_case_list[x]['test_describe'],
                                        test_case_list[x]['relevance_case'])
                    result_temp, response = ifd.interface_test()
            # 该用例已执行过,不需要再次执行
            else:
                LogPrint().info("----------------第" +
                                str(test_case_list[x]['num']) +
                                "个测试用例已执行----------------")
                continue
            check_list.append(int(test_case_list[x]['num']))

            # LogPrint().info(('-------第' + str(test_case_list[x]['num']) + '个用例的结果是-------:' + result_temp))
            LogPrint().info(
                "----------------根据用例执行情况,开始更新测试结果表的相关数据----------------")
            if result_temp == 'success':
                CommonMethod.sql_deal_two(md, conn, cur, 'success_num',
                                          result_id)
            elif result_temp == 'fail':
                CommonMethod.sql_deal_two(md, conn, cur, 'fail_num', result_id)
            elif result_temp == 'error':
                CommonMethod.sql_deal_two(md, conn, cur, 'error_num',
                                          result_id)
            else:
                LogPrint().info(
                    "----------------被关联的测试用例结果已更新,无需再次更新----------------")