def test_run(self, case):
        # 3、重构函数内容
        # data_key = ExcelConfig.DataConfig
        # run_list第1个用例,用例,key获取values
        url = ConfigYaml().get_conf_url() + case[data_key.url]
        print(url)
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]

        # 1、验证前置条件
        if pre_exec:
            pass
            # 2、找到执行用例
            # 前置测试用例
            pre_case = data_init.get_case_pre(pre_exec)
            print("前置条件信息为:%s" % pre_case)
            pre_res = self.run_pre(pre_case)
            print(pre_res)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)

        header = Base.json_parse(headers)
        cookie = Base.json_parse(cookies)
        res = self.run_api(url, method, params, header, cookie)
        print("测试用例执行:%s" % res)

        # allure
        # sheet名称  feature 一级标签
        allure.dynamic.feature(sheet_name)
        # 模块   story 二级标签
        allure.dynamic.story(case_model)
        # 用例ID+接口名称  title
        allure.dynamic.title(case_id + case_name)
        # 请求URL  请求类型 期望结果 实际结果描述
        desc = "<font color='red'>请求URL: </font> {}<Br/>" \
               "<font color='red'>请求类型: </font>{}<Br/>" \
               "<font color='red'>期望结果: </font>{}<Br/>" \
               "<font color='red'>实际结果: </font>{}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        # 断言验证
        # 状态码,返回结果内容,数据库相关的结果的验证
        # 状态码
        assert_util = AssertUtil()
        assert_util.assert_code(int(res["code"]), int(code))
        # 返回结果内容
        assert_util.assert_in_body(str(res["body"]), str(expect_result))
        # 数据库结果断言
        Base.assert_db("db_1", res["body"], db_verify)
Пример #2
0
    def test_run(self, case):
        # data_key = ExcelConfig.DataConfig
        url = case[data_key.url]
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        actual_result = case[data_key.actual_result]
        beizhu = case[data_key.beizhu]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]

        if pre_exec:
            # 前置用例
            pre_case = data_init.get_case_pre(pre_exec)
            # print(f"前置条件信息为:{pre_case}")
            pre_res = self.run_pre(pre_case)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)

        # 增加headers
        header = Base.json_parse(headers)
        # 增加cookies
        cookie = Base.json_parse(cookies)
        request = Request(ConfigYaml().get_config_url())
        # params转义json
        # 验证params有没有内容
        res = self.run_api(url, params, method, header, cookie)
        print(f"执行测试用例:{res}")

        # allure
        allure.dynamic.feature(sheet_name)
        allure.dynamic.story(case_model)
        allure.dynamic.title(case_id + case_name)
        desc = f"url:{url}<br> 请求方法:{method}<br> 期望结果:{expect_result}<br> 实际结果:{res}"
        allure.dynamic.description(desc)

        # 断言验证
        assert_util = AssertUtil()
        assert_util.assert_code(int(res['code']), code)
        assert_util.assert_in_body(str(res['body']), str(expect_result))

        # 数据库验证
        # sql = Base.init_db('db_1')
        # db_res = sql.fetch_one(db_verify)
        # log.debug(f"数据库查询结果:{str(db_res)}")
        # for db_k,db_v in db_res.items():
        #     res_line = res['body'][db_k]
        #     assert_util.assert_body(res_line, db_v)
        Base.assert_db(db_name='db_1',
                       res_body=res['body'],
                       db_verify=db_verify)
Пример #3
0
    def test_run(self, case):
        # run_list第1个用例,用例,key获取values
        url = ConfigYaml().get_conf_url() + case[data_key.url]

        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]

        # 2.增加Headers
        # 3.增加cookies
        # 4.发送请求
        if pre_exec:
            # 前置测试用例
            pre_case = data_init.get_case_pre(pre_exec)
            print("前置条件信息为:%s" % pre_case)
            pre_res = self.run_pre(pre_case)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)
        # 1.判断headers是否存在,json转义,无需
        header = Base.json_param(headers)
        cookie = Base.json_param(cookies)
        res = self.run_api(url,
                           method,
                           params=params,
                           header=header,
                           cookie=cookie)
        print("测试用例执行:%s" % res)

        # allure
        # sheet名称  feature 一级标签
        allure.dynamic.feature(sheet_name)
        # 模块   story 二级标签
        allure.dynamic.story(case_model)
        # 用例ID+接口名称  title
        allure.dynamic.title(case_id + case_name)
        # 请求URL  请求类型 期望结果 实际结果描述
        desc = "<font color='red'>请求URL111: </font> {}<Br/>" \
               "<font color='red'>请求类型222: </font>{}<Br/>" \
               "<font color='red'>期望结果: </font>{}<Br/>" \
               "<font color='red'>实际结果: </font>{}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        # 断言验证
        # 状态码,返回结果内容,数据库相关的结果的验证
        assert_util = AssertUtil()
        assert_util.assert_code(int(res['code']), code)
        # 返回结果内容
        assert_util.assert_in_body(str(res["body"]), str(expect_result))
        Base.assert_db("db_1", res["body"], db_verify)
Пример #4
0
    def test_run(self, case):
        # 初始化信息,url.data 等数据
        url = ConfigYml().get_conf_url() + case[data_key.url]
        print(url)
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        reference = case[data_key.reference]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verity = case[data_key.db_verity]

        # 验证前置条件
        if pre_exec:
            pass
            # 找到执行用例,前置测试用例
            pre_case = data_init.get_case_pre(pre_exec)
            # print("前置条件信息为:%s" % pre_case)
            pre_res = self.run_pre(pre_case)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)
        # 判断headers和cookie是否存在,如果存在json转义,如果不存在无需转义
        header = Base.json_parse(headers)
        cookie = Base.json_parse(cookies)
        url_params = Base.joint_url(case[data_key.params], case[data_key.url])
        res = self.run_api(url, method, url_params, reference, params, header,
                           cookie)
        print("测试用例执行:%s" % res)

        # allure
        allure.dynamic.feature(sheet_name)  # sheet名称   feature 一级标签
        allure.dynamic.story(case_model)  # 模块    story 二级标签
        allure.dynamic.title(case_id + case_name)  # 用例ID+接口名称 title
        # 请求URL 请求类型 期望结果 实际结果描述
        desc = "<font color='red'>请求URL: </font> {}<Br/>" \
               "<font color='red'>请求类型: </font>{}<Br/>" \
               "<font color='red'>期望结果: </font>{}<Br/>" \
               "<font color='red'>实际结果: </font>{}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        # 断言验证
        assert_util = AssertUtil()
        assert_util.assert_code(int(res["code"]), int(code))  # 验证状态码
        assert_util.assert_in_body(str(res["body"]),
                                   str(expect_result))  # 验证返回结果内容
        if len(db_verity) > 0:  # 数据库结果断言
            Base.assert_db("db_1", res["body"], db_verity)
Пример #5
0
    def test_run(self, case):
        # print("-----------------",case)
        # 重构函数内容
        # data_key = ExcelConfig.DataConfig
        #run_list 第1个用例,key获取values
        url = ConfigYaml().get_conf_url() + case[data_key.url]
        print("----------", url)
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cooikes = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]
        #接口请求

        #验证前置条件:
        if pre_exec:
            pass
            #找到执行用例
            # 前置测试用例
            pre_case = data_init.get_case_pre()
            print("前置条件信息为%s" % pre_exec)
            pre_res = self.run_pre(pre_case)
            headers, cooikes = self.get_correlation(headers, cooikes, pre_res)

        header = Base.json_parse(headers)
        cooikes = Base.json_parse(cooikes)
        res = self.run_api(url, method, params, headers, cooikes)
        print("测试用例执行:%s" % res)
        # #接口请求
        # request = Request()
        # #params转义json
        # if len(str(params).strip()) is not 0:
        #     params = json.loads(params)
        # #method post、get
        # if str(method).lower() == "get":
        #     #增加了headers
        #     res = request.get(url, json=params,headers = header,cooikes=cookie)
        # elif str(method).lower() == "post":
        #     res = request.post(url, json=params,headers = header,cooikes=cookie)
        # else:
        #     log.error("错误的请求method %s" % method)
        # print(res)

        #allure
        #sheet名称  feature一级标签
        allure.dynamic.feature(sheet_name)
        #模块   story 二级标签
        allure.dynamic.story(case_model)
        #用例ID+接口名称  title
        allure.dynamic.title(case_id + case_name)
        #请求url  请求类型  期望结果   实际结果描述
        desc = "<font color = 'red'>请求URL:</font>{}<br/>" \
               "<font color = 'red'>请求类型:</font>{}<br/>" \
               "<font color = 'red'>期望结构:</font>{}<br/>" \
               "<font color = 'red'>实际结果:</font>{}".format(url,method,expect_result,res)
        allure.dynamic.description(desc)

        # TestExcel().test_run()
        #断言验证
        #状态码

        assert_util = AssertUtil()
        assert_util.assert_code(int(res["code"]), int(code))
        #返回结果内容
        assert_util.assert_in_body(res["body"], str(expect_result))
        #数据库结果断言
        #初始化数据库
        Base.assert_db("db_1", res("body"), db_verify)
        from common.Base import init_db
    def test_run(self,case):
        # 3、重构函数内容
        data_key = ExcelConfig.DataConfig
        # run_list第1个用例,用例key获取values
        url = ConfigYaml().get_conf_url() + case[data_key.url]
        print(url)
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        status_code = case[data_key.status_code]
        db_verify = case[data_key.db_verify]

        # 2).接口请求
        request = Request()
        # params 转义json
        # 验证params有没有内容
        if len(str(params).strip()) is not 0:
            params = json.loads(params)
        # headers 转义json
        # 验证headers有没有内容
        if len(str(headers).strip()) is not 0:
            headers = json.loads(headers)
        # cookies 转义json
        # 验证cookies有没有内容
        if len(str(cookies).strip()) is not 0:
            cookies = json.loads(cookies)

        # method post/get
        if str(method).lower() == "get":
            res = request.get(url, data=params, headers=headers, cookies=cookies)

        elif str(method).lower() == "post":
            res = request.post(url, data=params, headers=headers, cookies=cookies)

        else:
            res = log.error("错误请求method: %s" % method)
        print(res)

        # allure
        # sheet名称  feature 一级标签
        allure.dynamic.feature(sheet_name)
        # 模块   story 二级标签
        allure.dynamic.story(case_model)
        # 用例ID+接口名称  title
        allure.dynamic.title(case_id + case_name)
        # 请求URL  请求类型 期望结果 实际结果描述
        desc = "<font color='red'>请求URL: </font> {}<Br/>" \
               "<font color='red'>请求类型: </font>{}<Br/>" \
               "<font color='red'>期望结果: </font>{}<Br/>" \
               "<font color='red'>实际结果: </font>{}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        # 断言验证
        # 状态码,返回结果内容,数据库相关的结果的验证
        # 状态码
        assert_util = AssertUtil()
        assert_util.assert_code(int(res["code"]), int(status_code))

        # 返回结果内容
        assert_util.assert_in_body(str(res["body"]), str(expect_result))
Пример #7
0
    def test_run(self, case):
        # excel中取得用例数据
        case_num = case[data_key.case_num]
        host = case[data_key.host]
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        note = case[data_key.note]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        body = case[data_key.body]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        last_result = case[data_key.last_result]
        exclude_regex_paths = case[data_key.exclude_regex_paths]
        db_verify = case[data_key.db_verify]

        # 如果是预设的常用参数就替换下
        if headers in global_params.keys():
            headers = global_params[headers]
        if host in global_params.keys():
            host = global_params[host]
        url = host + case[data_key.url]

        # 如果有参数中有需要执行前置用例的,就执行前置用例并替换参数
        if pre_exec:
            pre_case = Data_init.get_case_pre(pre_exec)
            print("前置条件信息为:%s" % pre_case)
            pre_res = self.run_pre(pre_case)
            headers, cookies, params, body, url \
                = Base.get_pre_exec_correlation(headers, cookies, params, body, url, pre_res)

        headers = Base.json_parse(headers)
        cookies = Base.json_parse(cookies)
        params = Base.json_parse(params)
        body = Base.json_parse(body)

        # 上面把数据都准备完成了,真正发请求
        res = Base.run_api(url, method, params, body, headers, cookies)

        # allure报告信息
        allure.dynamic.feature(sheet_name_keys)
        allure.dynamic.story(case_model)
        allure.dynamic.title(case_id + case_name)
        desc = "<font color='red'>请求URL:</font>{0}<BR/>" \
               "<font color='red'>请求方法:</font>{1}<BR/>" \
               "<font color='red'>预期结果:</font>{2}<BR/>" \
               "<font color='red'>实际结果:</font>{3}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        # log记录
        log.info("=====接口【%s】的用例【%s%s】已执行!=====" % (case_name, case_id, note))
        log.debug("\n测试用例预期:%s \n测试用例执行结果:%s" % (str(expect_result), str(res)))

        # 响应状态码及响应体字符串包含断言
        assert_util = AssertUtil()
        assert_util.assert_code(res["code"], code)
        assert_util.assert_in_body(str(res["body"]), str(expect_result))

        # 响应体的diff断言
        if exclude_regex_paths != "skip_diff":
            if last_result:
                expect_result_for_diff = json.loads(
                    json.dumps(eval(last_result)))
                if len(exclude_regex_paths) > 5:
                    exclude_regex_paths = eval(exclude_regex_paths)
                else:
                    exclude_regex_paths = None
                assert_util.assert_diff(
                    expect_result_for_diff,
                    res,
                    exclude_regex_paths=exclude_regex_paths)
            else:
                from utils.ExcelUtil import ExcelUtil
                sheet_by = getattr(Const.GetConst(), (case_num[0:1]).upper())
                excel_util = ExcelUtil(excel_file=case_file, sheet_by=sheet_by)
                case_row = excel_util.get_row_num_by_case_num(case_num)
                excel_util.write_back(case_row, 16, str(res))

        # 数据库断言
        if db_verify:
            assert_util.assert_db(db_verify)
Пример #8
0
    def test_run(self, case):

        #run_list 第一个用例,用例,key获取values
        url = ConfigYaml().get_conf_url() + case[data_key.url]
        print(url)
        case_id = case[data_key.case_id]
        # print(case_id)
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]

        #动态headers请求
        ##1.验证前置条件
        if pre_exec:
            pass

            ##2.找到执行用例
            pre_case = data_init.get_case_pre(pre_exec)

            print("前置条件信息为: %s" % pre_case)
            pre_res = self.run_pre(pre_case)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)

        header = Base.json_parse(headers)
        cookie = Base.json_parse(cookies)
        res = self.run_api(url, method, params, header, cookie)
        print("测试用例执行: %s" % res)
        # return res  # 注意

        # sheet名称--feature 一级标签
        allure.dynamic.feature(sheet_name)
        # 模块--story 二级标签
        allure.dynamic.story(case_model)
        # 用例ID + 接口名称 - - title
        allure.dynamic.title(case_id + case_name)
        #请求URL 请求类型 期望结果 实际结果 description
        # allure.dynamic.description(url+method+expect_result+res)
        desc = "<font color='green' size=3>请求URL: </font> {}<Br/>" \
               "<font color='green' size=3>请求类型: </font>{}<Br/>" \
               "<font color='red' size=3>期望结果: </font>{}<Br/>" \
               "<font color='green' size=3>实际结果: </font>{}".format(url, method, expect_result, res)
        allure.dynamic.description(desc)

        #1.断言验证
        #2.状态码,返回结果内容,数据库相关结果验证
        #"""断言验证--状态码,返回结果内容,数据库相关的结果的验证"""
        #1.)状态码
        assert_util = AssertUtil()
        assert_util.assert_code(int(res["code"]), int(code))
        #2.)返回结果内容验证
        assert_util.assert_in_body(str(res["body"]), str(expect_result))
        #********数据库结果断言********
        Base.assert_db("db_1", res["body"], db_verify)
    def test_run(self, case):
        # data_key = ExcelConfig.DataConfig
        # run_list第一个用例
        url = ConfigYaml().get_conf_url() + case[data_key.url]
        # print(url)
        case_id = case[data_key.case_id]
        case_model = case[data_key.case_model]
        case_name = case[data_key.case_name]
        pre_exec = case[data_key.pre_exec]
        method = case[data_key.method]
        params_type = case[data_key.params_type]
        params = case[data_key.params]
        expect_result = case[data_key.expect_result]
        headers = case[data_key.headers]
        cookies = case[data_key.cookies]
        code = case[data_key.code]
        db_verify = case[data_key.db_verify]

        # # 判断headers是否存在,json转义
        # if headers:
        #     header = json.loads(headers)
        # else:
        #     header = headers
        # # 增加cookies
        # if cookies:
        #     cookie = json.loads(cookies)
        # else:
        #     cookie = cookies

        # 验证前置条件
        if pre_exec:
            # 执行测试用例
            pre_case = data_init.get_case_pre(pre_exec)
            # print("前置条件为:%s"%pre_case)
            pre_res = self.run_pre(pre_case)
            headers, cookies = self.get_correlation(headers, cookies, pre_res)
        header = Base.json_parse(headers)
        cookie = Base.json_parse(cookies)
        res = self.run_api(url, method, params, header, cookie)
        print("测试用例执行:%s" % res)

        # allure
        '''
        sheet名称 feature 一级标签
        模块  story   二级标签
        用例ID+接口名称   title
        请求url、请求类型、期望结果、实际结果    描述
        '''
        allure.dynamic.feature(sheet_name)
        allure.dynamic.story(case_model)
        allure.dynamic.title(case_id + case_name)
        desc = "<font color='red'> 请求URL:</font> {} <Br/> " \
               "<font color='red'> 请求类型:</font> {} <Br/> " \
               "<font color='red'> 期望结果:</font> {} <Br/> " \
               "<font color='red'> 实际结果:</font> {} ".format(url,method,expect_result,res)
        allure.dynamic.description(desc)

        # 断言验证
        # 状态码,返回结果内容,数据库相关结果验证
        assert_util = AssertUtil()
        assert_util.assert_code((res['code']), int(code))
        # 返回结果内容,body
        assert_util.assert_in_body(str(res["body"]), str(expect_result))
        # 数据库断言
        Base.assert_db("db_1", res['body'], db_verify)