十、断言方法封装

实现功能：
封装接口测试中的断言逻辑。它支持多种断言模式，包括状态码断言、包含模式断言、相等断言
1、函数设计
Assertions

• status_code_assert 方法：
  - 比较接口返回的状态码与预期状态码。
  - 返回一个标志值，表示断言是否成功。
• contain_assert 方法：
  - 检查预期结果字符串是否包含在实际响应的信息中。key：value
  - 使用 jsonpath 提取响应中key的 value值，将预期value值使用in（响应value值）并进行包含性检查。
  - 返回一个标志值，表示断言是否成功。
• equal_assert 方法：
  - 比较预期结果与实际响应结果是否相等
  - 找出共同的键，生成实际结果字典：new_actual_result = {"data": {"token": "abc123", "user_id": 12345}}，比较预期结果和实际结果使用 operator.eq 对进行相等性检查。
  - 返回一个标志值，表示断言是否成功。
• assert_result 方法：
  - 主断言函数，根据 expected_result 中的断言模式调用相应的断言方法。
  - 支持多种断言模式（如状态码、包含模式、相等模式）。
  - 使用 all_flag 标志值来记录所有断言的失败情况。
  - 最终断言 all_flag 是否为 0，以确定测试是否成功。

2、代码

点击查看代码

"""
status_code_assert
：状态码断言。
contain_assert
：包含模式断言。
equal_assert
：相等断言。
assert_result
：主断言函数，调用其他断言方法并记录失败情况。
"""

import jsonpath
import operator


class Assertions:
    """
    接口断言模式封装
    1、状态码断言(已实现)
    2、包含模式断言（已实现）
    3、相等断言（已实现）
    4、不相等断言
    5、数据库断言
    """

    @classmethod
    def status_code_assert(cls, expected_result, status_code):
        """
        接口响应状态码断言
        :param expected_result:yaml文件中code模式的预期状态码
        :param status_code:接口实际返回的状态码
        :return:
        """
        # 断言状态标识，0表示成功，其它表示失败
        failure_count = 0
        if expected_result == status_code:
            print(f'状态码断言成功：接口实际返回的状态码{status_code}=={expected_result}')
        else:
            print(f'状态码断言失败：接口实际返回的状态码{status_code}!={expected_result}')
            failure_count += 1

        return failure_count

    @classmethod
    def contain_assert(cls, expect_result, response):
        """
        字符串包含模式，断言预期结果字符串是否包含在实际响应的信息中
        :param expect_result:(dict)yaml文件里面contain模式的数据
        :param response:(dict)接口的实际响应信息
        :return:
        """
        # 断言状态标识，0表示成功，其它表示失败
        failure_count = 0
        for assert_key, assert_value in expect_result.items():
            # print(assert_key,assert_value)
            response_list = jsonpath.jsonpath(response, f'$..{assert_key}')
            # print(response_list)
            if response_list and isinstance(response_list[0], str):
                response_str = ''.join(response_list)
                if assert_value in response_str:
                    print(f'包含断言模式成功：预期结果【{assert_value}】存在于实际结果【{response_str}】中')
                else:
                    failure_count += 1
                    print(f'包含断言模式失败：预期结果【{assert_value}】未在实际结果【{response_str}】中找到')
        return failure_count

    @classmethod
    def equal_assert(cls, expect_result, response):
        """
        相等断言，根据yaml文件中的validation关键词下面eq模式去和实际返回比对
        :param expect_result:(dict)yaml文件里的eq值
        :param response:(dict)接口实际响应结果
        :return:
        """
        failure_count = 0
        if isinstance(response, dict) and isinstance(expect_result, dict):
            # print(f'yaml的预期结果：{expect_result}')
            print(f'接口的实际结果：{response}')
            # 找出实际结果于预期结果共同的key值
            common_key = list(expect_result.keys() & response.keys())[0]
            if common_key:
                common_key = common_key[0]
                # 根据相同的key去实际结果中获取，并重新生成一个实际结果中的字典
                new_actual_result = {common_key: response[common_key]}
                eq_assert = operator.eq(new_actual_result, expect_result)
                if eq_assert:
                    print(f'相等断言成功，接口实际结果{new_actual_result}== 预期结果{expect_result}')
                else:
                    failure_count += 1
                    print(f'相等断言失败，接口实际结果{new_actual_result}！= 预期结果{expect_result}')
            else:
                failure_count += 1
                print('相等断言失败，请检查yaml文件eq模式字段是否存在接口返回信息中')
        return failure_count

    @classmethod
    def assert_result(cls, expected_result, response, status_code):
        """
        断言主函数，通过all_flag标记，如all_flag ==0表示测试成功，否则为失败
        :param expected_result:(list)yaml文件validation关键词下面的预期结果
        :param response:接口的实际响应信息
        :param status_code:接口的实际响应状态码
        :return:
        """
        all_flag = 0
        assert_methods = {
            'code': cls.status_code_assert,
            'contain': cls.contain_assert,
            'eq': cls.equal_assert,
        }

        try:
            print(expected_result)
            for yq in expected_result:
                for assert_mode, assert_value in yq.items():
                    assert_method = assert_methods.get(assert_mode)
                    if assert_method:
                        # 调用对应的断言方法，传递适当的参数
                        if assert_mode == 'code':
                            flag = assert_method(assert_value, status_code)
                        else:
                            flag = assert_method(assert_value, response)
                        all_flag += flag
                    else:
                        print(f'不支持{assert_mode}该断言模式')
        except Exception as e:
            pass

        assert all_flag == 0, '测试失败'
        print('测试成功')