pytest-api-framework-alpha 0.2.2__tar.gz → 0.2.3__tar.gz

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-api-framework-alpha
-Version: 0.2.2
+Version: 0.2.3
 Author: alpha
 Author-email: 
 Requires-Python: >=3.6

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/allure_report.py

@@ -3,7 +3,7 @@ import os
 import platform
 from framework.utils.log_util import logger
 from framework.global_attribute import CONTEXT
-from config.settings import ALLURE_DIR, ALLURE_REPORT_DIR, ALLURE_RESULTS_DIR, ALLURE_ENV_PROPERTIES
+from framework.settings import ALLURE_DIR, ALLURE_REPORT_DIR, ALLURE_RESULTS_DIR, ALLURE_ENV_PROPERTIES
 
 
 def generate_report():

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/base_class.py

@@ -5,16 +5,16 @@ from urllib.parse import urlparse, urlunparse, urljoin
 
 import pytest
 from box import Box
-from faker import Faker
 
 from framework.exit_code import ExitCode
 from framework.db.redis_db import RedisDB
+from framework.db.mysql_db import MysqlDB
 from framework.utils.log_util import logger
 from framework.render_data import RenderData
 from framework.http_client import ResponseUtil
+from framework.settings import UNAUTHORIZED_CODE, FAKER_LANGUAGE
 from framework.utils.common import snake_to_pascal, SingletonFaker
 from framework.global_attribute import CONFIG, GlobalAttribute, _FRAMEWORK_CONTEXT
-from config.settings import UNAUTHORIZED_CODE, FAKER_LANGUAGE
 
 module = importlib.import_module("test_case.conftest")
 
@@ -36,7 +36,6 @@ class BaseTestCase(object):
             app_http = getattr(self.http, app)
             domain = self.context.get(app).get("domain")
             data = RenderData(data).render()
-            url = data.request.get("url")
             data.request.url = self.replace_domain(data.request.url, domain)
             self.response = getattr(app_http, account).request(data=data, kwargs=kwargs)
             if self.response.status_code in UNAUTHORIZED_CODE:
@@ -76,16 +75,16 @@ class BaseTestCase(object):
         request.update({"method": "delete", "headers": {}, **kwargs})
         return self.request(app=app, account=account, data=Box({"request": request}))
 
-    def mysql_conn(self, db, app=None):
+    def mysql_conn(self, db, app=None) -> MysqlDB:
         try:
             return _FRAMEWORK_CONTEXT.get(app=self.default_app(app), key="mysql").get(db)
         except AttributeError as e:
             traceback.print_exc()
             pytest.exit(ExitCode.LOAD_DATABASE_INFO_ERROR)
 
-    def redis_conn(self, db, app=None):
+    def redis_conn(self, db, index=0, app=None) -> RedisDB:
         try:
-            return RedisDB(**CONFIG.get(app=self.default_app(app), key="redis").get(db))
+            return _FRAMEWORK_CONTEXT.get(app=self.default_app(app), key="redis").get(db)[index]
         except AttributeError as e:
             traceback.print_exc()
             pytest.exit(ExitCode.LOAD_DATABASE_INFO_ERROR)

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/conftest.py

@@ -22,12 +22,12 @@ from framework.exit_code import ExitCode
 from framework.db.mysql_db import MysqlDB
 from framework.db.redis_db import RedisDB
 from framework.utils.log_util import logger
-from framework.render_data import RenderData
+# from framework.render_data import RenderData
 from framework.utils.yaml_util import YamlUtil
+from framework.settings import DATA_DIR, CASES_DIR
 from framework.allure_report import generate_report
 from framework.global_attribute import CONTEXT, CONFIG, _FRAMEWORK_CONTEXT
 from framework.utils.common import snake_to_pascal, get_apps, convert_numbers_to_decimal
-from config.settings import DATA_DIR, CASES_DIR
 
 all_app = get_apps()
 module = importlib.import_module("test_case.conftest")
@@ -139,6 +139,12 @@ def pytest_generate_tests(metafunc):
         if not case_common.get("url"):
             logger.warning(f"{func_file_path} request中缺少必填字段: url", case_data)
             # pytest.exit(ExitCode.YAML_MISSING_FIELDS)
+        else:
+            url = case_common.get("url")
+            if url.strip().startswith("${"):
+                case_data["request"]["url"] = url
+            else:
+                case_data["request"]["url"] = urljoin(domain, url)
     else:
         if url.strip().startswith("${"):
             case_data["request"]["url"] = url
@@ -150,6 +156,8 @@ def pytest_generate_tests(metafunc):
         if not case_common.get("method"):
             logger.warning(f"{func_file_path} request中缺少必填字段: method", case_data)
             # pytest.exit(ExitCode.YAML_MISSING_FIELDS)
+        else:
+            case_data["request"]["method"] = case_common.get("method")
 
     for key in ["title", "level"]:
         if key not in case_data:
@@ -179,8 +187,9 @@ def pytest_generate_tests(metafunc):
                 # 剔除标记disable的字段
                 deep_copied_case_data = disable_field(scenario.get("data"), deep_copied_case_data)
                 deep_copied_case_data["_scenario"] = item.get("scenario")
+                deep_copied_case_data["_ignore_failed"] = case_common.get("ignore_failed", False)
                 case_data_list.append(deep_copied_case_data)
-                ids.append(case_data.get("title") + f"#{index + 1}")
+                ids.append(f'{case_data.get("title")} - {scenario.get("describe", "")}#{index + 1}')
             except KeyError as e:
                 logger.error(f"scenario参数化格式不正确:{e}")
                 traceback.print_exc()
@@ -189,6 +198,7 @@ def pytest_generate_tests(metafunc):
     else:
         if not case_common.get("ignore"):
             case_data["_scenario"] = {"data": {}}
+            case_data["_ignore_failed"] = case_common.get("ignore_failed", False)
             case_data_list = [case_data]
         # 进行参数化生成用例
         metafunc.parametrize("data", case_data_list, ids=[f'{case_data.get("title")}#1'], scope="function")
@@ -408,9 +418,11 @@ def pytest_runtest_call(item):
     :param item:
     :return:
     """
+    origin_data = item.funcargs.get("data")
     func_name = item.originalname
+    ignore_failed = origin_data.get("_ignore_failed")
     ignore_error_and_continue = item.config.getini("ignore_error_and_continue")
-    if ignore_error_and_continue == "false":
+    if not (ignore_failed is True or ignore_error_and_continue == "true"):
         # setup方法执行失败，则主动标记用例执行失败，不会执行用例
         if item.funcargs.get("setup_success") is False:
             pytest.skip("test_before_scenario execute error")
@@ -590,6 +602,15 @@ def login():
         mysqls = CONFIG.get(app=app, key="mysql")
         mysqls_obj = {item: MysqlDB(**mysqls.get(item)) for item in mysqls.keys()}
         _FRAMEWORK_CONTEXT.set(app=app, key="mysql", value=mysqls_obj)
+        redis = CONFIG.get(app=app, key="redis")
+        redis_obj = {
+            db: [
+                RedisDB(**{**db_info, "db": i})
+                for i in range(16)
+            ]
+            for db, db_info in redis.items()
+        }
+        _FRAMEWORK_CONTEXT.set(app=app, key="redis", value=redis_obj)
 
     try:
         logger.info("登录账号".center(80, "*"))

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/db/redis_db.py

@@ -7,7 +7,7 @@ from framework.utils.log_util import logger
 
 class RedisDB(Redis):
 
-    def __init__(self, host, port, password, db, max_connections=10):
+    def __init__(self, host, port, password, db, max_connections=1):
         super(RedisDB, self).__init__()
         self.db = db
         self.max_connections = max_connections
@@ -56,7 +56,7 @@ class RedisDB(Redis):
 
         if value:
             if isinstance(value, dict):
-                self.push(name, value)
+                self.conn.lpush(name, json.dumps(value, ensure_ascii=False))
             elif isinstance(value, list):
                 if isinstance(value[0], dict):
                     value = [json.dumps(item, ensure_ascii=False) for item in value]
@@ -102,41 +102,58 @@ class RedisDB(Redis):
     def set_ttl(self, name, time):
         res = self.conn.expire(name, time)
         logger.info(f'expire {name} {time} ---> {res}')
-        if res:
-            return res
-        else:
-            return False
+        return res
 
     def exists(self, name):
         res = self.conn.exists(name)
         logger.info(f'exists {name} ---> {res}')
-        if res:
-            return True
-        else:
-            return False
+        return res
 
     def delete(self, name):
         res = self.conn.delete(name)
         logger.info(f'delete {name} ---> {res}')
-        if res:
-            return True
-        else:
-            return False
+        return res
 
-    def push(self, name, value):
+    def lpush(self, name, *value):
         """
-        通过list实现队列，从左侧推消息,消息体只能字典
+        通过list实现队列，从左侧推消息
         :param name:
         :param value:
         :return:
         """
-        res = self.conn.lpush(name, json.dumps(value, ensure_ascii=False))
+        res = self.conn.lpush(name, *value)
         logger.info(f'lpush {name} ---> {value}')
-        if res:
-            return True
-        else:
-            return False
+        return res
+
+    def rpush(self, name, *value):
+        """
+        通过list实现队列，从右侧推消息
+        :param name:
+        :param value:
+        :return:
+        """
+        res = self.conn.rpush(name, *value)
+        logger.info(f'rpush {name} ---> {value}')
+        return res
 
+    def lpop(self, queue_name):
+        logger.info(f'lpop {queue_name}')
+        return self.conn.lpop(queue_name)
 
-if __name__ == '__main__':
-    redis = RedisDB(db=0)
+    def rpop(self, queue_name):
+        logger.info(f'rpop {queue_name}')
+        return self.conn.rpop(queue_name)
+
+    def lpop_all(self, queue_name):
+        """弹出并返回队列中所有元素（会清空队列）"""
+        all_elements = []
+        try:
+            while True:
+                element = self.conn.lpop(queue_name)
+                if element is None:
+                    break  # 队列为空时退出循环
+                all_elements.append(element)
+            return all_elements
+        except Exception as e:
+            print(f"获取所有元素失败: {e}")
+            return []

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/global_attribute.py

@@ -1,21 +1,38 @@
 import os
 import traceback
-import yaml
+from pathlib import Path
 
+import yaml
 import pytest
 from box import Box
+from dotenv import set_key
 from box.exceptions import BoxError
 
-from config.settings import ROOT_DIR
 from framework.exit_code import ExitCode
 from framework.utils.log_util import logger
-from framework.utils.common import singleton
+from framework.settings import ROOT_DIR
 
 
 class NoDatesSafeLoader(yaml.SafeLoader):
     pass
 
 
+def singleton(cls):
+    """
+    单例模式装饰器
+    :param cls:
+    :return:
+    """
+    instances = {}
+
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance
+
+
 # 禁用 YAML 中的 timestamp 类型自动转换
 for ch in list(NoDatesSafeLoader.yaml_implicit_resolvers):
     resolvers = NoDatesSafeLoader.yaml_implicit_resolvers[ch]

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/http_client.py

@@ -14,7 +14,7 @@ from framework.extract import Extract
 from framework.validate import Validate
 from framework.utils.log_util import logger
 from framework.global_attribute import CONTEXT
-from config.settings import CONSOLE_DETAILED_LOG
+from framework.settings import CONSOLE_DETAILED_LOG
 from framework.utils.common import convert_numbers_to_decimal
 
 
@@ -113,33 +113,35 @@ class HttpClient(object):
                 logger.info(f"请求url: {request_obj.get('url')}")
             with allure.step(f"请求method: {request_obj.get('method')}"):
                 logger.info(f"请求method: {request_obj.get('method')}")
-            with allure.step(f"请求headers: {request_obj.get('headers')}"):
+            with allure.step(f"请求headers: {built_json.dumps(request_obj.get('headers'))}"):
                 if CONSOLE_DETAILED_LOG:
-                    logger.info(f"请求headers: {request_obj.get('headers')}")
+
+                    logger.info(f"请求headers: {built_json.dumps(request_obj.get('headers'))}")
             if request_obj.get('params'):
-                with allure.step(f"请求参数params: {request_obj.get('params')}"):
-                    logger.info(f"请求参数params: {request_obj.get('params')}")
+                with allure.step(f"请求参数params: {built_json.dumps(request_obj.get('params'))}"):
+                    logger.info(f"请求参数params: {built_json.dumps(request_obj.get('params'))}")
             if request_obj.get('data'):
-                with allure.step(f"请求参数data: {request_obj.get('data')}"):
-                    logger.info(f"请求参数data: {request_obj.get('data')}")
+                with allure.step(f"请求参数data: {built_json.dumps(request_obj.get('data'))}"):
+                    logger.info(f"请求参数data: {built_json.dumps(request_obj.get('data'))}")
             if request_obj.get('json'):
-                with allure.step(f"请求参数json: {request_obj.get('json')}"):
-                    logger.info(f"请求参数json: {request_obj.get('json')}")
+                with allure.step(f"请求参数json: {built_json.dumps(request_obj.get('json'))}"):
+                    logger.info(f"请求参数json: {built_json.dumps(request_obj.get('json'))}")
 
         with allure.step("响应结果"):
             with allure.step(f"响应status code: {self.response.status_code}"):
                 logger.info(f"响应status code: {self.response.status_code}")
-            with allure.step(f"响应headers: {self.response.headers}"):
+
+            with allure.step(f"响应headers: {built_json.dumps(dict(self.response.headers))}"):
                 if CONSOLE_DETAILED_LOG:
-                    logger.info(f"响应headers: {self.response.headers}")
-            with allure.step(f"响应body: {self.response.json()}"):
-                logger.info(f"响应body: {self.response.json()}")
+                    logger.info(f"响应headers: {built_json.dumps(dict(self.response.headers))}")
+            with allure.step(f"响应body: {built_json.dumps(self.response.json())}"):
+                logger.info(f"响应body: {built_json.dumps(self.response.json())}")
 
         # 断言
         validates = data.get("validate")
         if validates:
             with allure.step("结果断言"):
-                Validate(self.response).valid(validates)
+                Validate(data, self.response).valid(validates)
 
         # 提取变量
         expressions = data.get("extract")

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/render_data.py

@@ -9,8 +9,8 @@ from box import Box
 from framework.exit_code import ExitCode
 from framework.utils.log_util import logger
 from framework.global_attribute import CONTEXT
-from framework.utils.common import SingletonFaker
-from config.settings import FAKER_LANGUAGE, DATA_DIR
+from framework.settings import FAKER_LANGUAGE, DATA_DIR
+from framework.utils.common import SingletonFaker, remove_spaces
 
 module = importlib.import_module("framework.utils.common")
 
@@ -34,11 +34,23 @@ class RenderData(object):
         """
         with allure.step("渲染数据"):
             self.replace_attribute(self.scenario)
+            self.render_url()
             self.replace_attribute(self.request)
         self.data["request"] = self.request
         self.data["_is_multipart"] = self._is_multipart
         return self.data
 
+    def render_url(self):
+        url = remove_spaces(self.request.url)
+        pattern = re.compile(r"\$\{([\w.\[\]0-9]+(?:\(\w*(?:,\w*)*\))?)}")
+
+        def replacer(match):
+            item = match.group(1)  # 拿到占位符里的内容
+            value = self.get_attribute(item)
+            return str(value) if value is not None else match.group(0)  # 未取到就保留原样
+
+        self.request.url = pattern.sub(replacer, url)
+        
     def replace_attribute(self, data):
         pattern = re.compile(r"\$\{([\w.\[\]0-9]+(?:\(\w*(?:,\w*)*\))?)}")
         file_path_pattern = re.compile(
@@ -52,6 +64,7 @@ class RenderData(object):
                     self.replace_attribute(value)
                 # 如果是字符串类型并匹配正则表达式，则替换
                 elif isinstance(value, str):
+                    value = remove_spaces(value)
                     if pattern.search(value):
                         data[key] = self.get_attribute(value[2:-1])
                     elif file_path_pattern.search(value):
@@ -66,6 +79,7 @@ class RenderData(object):
                     self.replace_attribute(item)
                 # 如果是字符串类型并匹配正则表达式，则替换
                 elif isinstance(item, str):
+                    item = remove_spaces(item)
                     if pattern.search(item):
                         data[index] = self.get_attribute(item[2:-1])
                     elif file_path_pattern.search(item):
@@ -73,7 +87,7 @@ class RenderData(object):
                         self._is_multipart = True
 
     def get_attribute(self, keyword):
-        if not keyword.endswith(")"):
+        if not keyword.strip().endswith(")"):
             return self.get_attribute_variable(keyword)
         # 如果关键字是函数
         else:
@@ -96,7 +110,7 @@ class RenderData(object):
         :param expression:
         :return:
         """
-        if not expression.startswith(tuple(f"{app}." for app in self.context.all_app)):
+        if not expression.strip().startswith(tuple(f"{app}." for app in self.context.all_app)):
             belong_app = self.data.get('_belong_app')
             new_expression = f"{belong_app}.{expression}"
         else:
@@ -108,23 +122,9 @@ class RenderData(object):
             if self.get_nested_value(self.context, new_expression) is not None else
             self.get_nested_value(self.context, expression)
         )
-        # if value.endswith(")}"):
-        #     keyword = value[2:-1]
-        #     try:
-        #         pattern = re.compile(r'(?P<func_name>.+)\((?P<args>.*)\)')
-        #         match = re.match(pattern, keyword)
-        #         # 匹配方法名
-        #         func_name = match.group("func_name")
-        #         # 匹配方法位置参数
-        #         args = match.group("args")
-        #         if args:
-        #             # 将参数中字符串类型的数字转成数字类型
-        #             args = [eval(i) for i in args.replace(",", "").split(",")]
-        #             value = self.get_func_variable(keyword, func_name, *args)
-        #         else:
-        #             value = self.get_func_variable(keyword, func_name)
-        #     except Exception:
-        #         pass
+        if isinstance(value, str) and value.strip().startswith("${") and value.strip().endswith("}"):
+            value = self.get_nested_value(self.context, new_expression) or self.get_nested_value(self.context,
+                                                                                                 expression)
 
         with allure.step(f"{expression}: {value}"):
             logger.info(f"前置读取变量: {expression}: {value}")

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/report.py

@@ -4,7 +4,7 @@ import datetime
 import traceback
 from pathlib import Path
 from framework.db.mysql_db import MysqlDB
-from config.settings import DATABASE_HOST, DATABASE_PASSWORD, DATABASE_DB, DATABASE_USERNAME, DATABASE_PORT
+from framework.settings import DATABASE_HOST, DATABASE_PASSWORD, DATABASE_DB, DATABASE_USERNAME, DATABASE_PORT
 
 
 def timestamp_to_datetime_str(timestamp):

pytest_api_framework_alpha-0.2.3/framework/settings.py

@@ -0,0 +1,30 @@
+import os
+
+ROOT_DIR = os.getcwd()
+# 生成allure报告程序的路径
+ALLURE_DIR = os.getenv("ALLURE_DIR")
+# allure统计执行结果目录
+ALLURE_RESULTS_DIR = os.path.join(ROOT_DIR, "allure_results")
+# allure报告目录
+ALLURE_REPORT_DIR = os.path.join(ROOT_DIR, "allure_report")
+# allure报告统计执行环境的存放路径
+ALLURE_ENV_PROPERTIES = os.path.join(ALLURE_RESULTS_DIR, "environment.properties")
+# 存放case的目录
+CASES_DIR = os.path.join(ROOT_DIR, "test_case")
+# 存放测试数据的目录
+DATA_DIR = os.path.join(ROOT_DIR, "test_data")
+# 存放配置的目录
+CONFIG_DIR = os.path.join(ROOT_DIR, "config")
+
+FAKER_LANGUAGE = "en_US"
+# 是否记录详细日志
+CONSOLE_DETAILED_LOG = False
+# 鉴权失败返回的http code
+UNAUTHORIZED_CODE = [401]
+# response属性
+RESPONSE_ATTR = ["status_code", "url", "ok", "encoding"]
+
+try:
+    from config.settings import *
+except ImportError:
+    pass

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/startapp.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import yaml
 from framework.utils.common import snake_to_pascal
-from config.settings import CONFIG_DIR, CASES_DIR, DATA_DIR
+from framework.settings import CONFIG_DIR, CASES_DIR, DATA_DIR
 
 
 def create_yaml(app):
@@ -68,6 +68,7 @@ def create_test_data(app):
             "case_common": {
                 "module": "功能模块名称",
                 "describe": "测试场景描述",
+                "ignore_failed": False,  # 默认false,遇到失败case会忽略当前类中后续case，直接执行下个测试类
                 "scenarios": [
                     {
                         "scenario": {

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/utils/common.py

@@ -11,8 +11,27 @@ from urllib.parse import unquote, quote, quote_plus, unquote_plus
 import pyotp
 import cn2an as c2a
 from faker import Faker
+from framework.settings import CONFIG_DIR
 
-from config.settings import CONFIG_DIR
+try:
+    from utils.common import *
+except ImportError:
+    pass
+
+
+class SingletonFaker(object):
+    instance = None
+    init_flag = False
+
+    def __init__(self, locale):
+        if self.init_flag:
+            return
+        self.faker = Faker(locale)
+
+    def __new__(cls, *args, **kwargs):
+        if cls.instance is None:
+            cls.instance = super().__new__(cls)
+        return cls.instance
 
 
 def generate_2fa_code(secret_key):
@@ -243,19 +262,9 @@ def convert_numbers_to_decimal(obj: Any) -> Any:
         return obj
 
 
-class SingletonFaker(object):
-    instance = None
-    init_flag = False
-
-    def __init__(self, locale):
-        if self.init_flag:
-            return
-        self.faker = Faker(locale)
-
-    def __new__(cls, *args, **kwargs):
-        if cls.instance is None:
-            cls.instance = super().__new__(cls)
-        return cls.instance
+def remove_spaces(s: str) -> str:
+    """去掉字符串中的所有空格"""
+    return s.replace(" ", "")
 
 
 if __name__ == '__main__':

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/framework/validate.py

@@ -1,21 +1,20 @@
 import re
 
 import allure
+import pytest
 from box import Box, BoxList
 from jsonpath import jsonpath
 
 from framework.utils.log_util import logger
+from framework.render_data import RenderData
+from framework.settings import RESPONSE_ATTR
 from framework.utils.common import an2cn, is_digit
 
 
 class Validate(object):
-    def __init__(self, response):
-        if isinstance(response.json(), dict):
-            self.response = Box(response.json())
-        elif isinstance(response.json(), list):
-            self.response = BoxList(response.json())
-        else:
-            self.response = response
+    def __init__(self, data, response):
+        self.data = data
+        self.response = response
 
         self.mapping = {
             "eq": "assert_equal",
@@ -32,7 +31,9 @@ class Validate(object):
             "contains": "assert_contains",
             "contained_by": "assert_contained_by",
             "startswith": "assert_startswith",
-            "endswith": "assert_endswith"
+            "endswith": "assert_endswith",
+            "is_null": "assert_is_null",
+            "not_null": "assert_is_not_null",
         }
 
     def valid(self, validates):
@@ -40,23 +41,26 @@ class Validate(object):
             key = list(valid_item.keys())[0]
             valid_list = [i.strip() for i in valid_item.get(key).split(",")]
             expression = valid_list[0]
-            expectant_result = valid_list[1]
+            try:
+                expectant_result = valid_list[1]
+            except IndexError:
+                expectant_result = ""
             func = self.mapping.get(key)
             try:
                 if func:
-                    getattr(self, func)(expression, expectant_result)
+                    result = getattr(self, func)(expression, expectant_result.strip())
                     with allure.step(
-                            f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: 断言通过"):
+                            f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: {result}"):
                         logger.info(
-                            f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: 断言通过")
+                            f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: {result}")
                 else:
                     logger.error(f"不支持的断言方式: {key}")
             except AssertionError as e:
                 with allure.step(
-                        f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: 断言失败。 失败原因: {e}"):
+                        f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: {result}。 失败原因: {e}"):
                     logger.error(
-                        f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: 断言失败。 失败原因: {e}")
-                logger.error(e)
+                        f"断言({an2cn(validates.index(valid_item) + 1)}): 断言类型: {self.mapping.get(key)}, 断言内容: {valid_list}, 断言结果: {result}。 失败原因: {e}")
+                pytest.fail(e)
 
     def parse_expectant_expression(self, expectant_expression):
 
@@ -78,7 +82,7 @@ class Validate(object):
 
     def exec_jsonpath(self, expression):
         try:
-            return jsonpath(self.response, expression)[0]
+            return jsonpath(self.response.json(), expression)[0]
         except Exception as e:
             raise Exception(f"jsonpath表达式错误或非预期响应内容{e} 表达式: {expression};响应内容: {self.response}")
 
@@ -94,7 +98,9 @@ class Validate(object):
 
     def exec_box(self, expression):
         try:
-            return self.get_nested_value(Box(self.response), expression)
+            if expression in RESPONSE_ATTR:
+                return getattr(self.response, expression)
+            return self.get_nested_value(Box(self.response.json()), expression)
         except Exception as e:
             raise Exception(f"box表达式或响应内容异常{e} 表达式: {expression}; 响应内容: {self.response.text}")
 
@@ -116,105 +122,164 @@ class Validate(object):
     def assert_equal(self, expectant_expression, practical_result):
         expectant_result = self.parse_expectant_expression(expectant_expression)
         if isinstance(expectant_result, (int, float)) and isinstance(practical_result, str):
-            practical_result = eval(practical_result)
+            if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith(
+                    "}"):
+                practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
+            else:
+                practical_result = eval(practical_result)
         assert practical_result == expectant_result, f'{expectant_result} == {practical_result}'
+        return f'{expectant_result} == {practical_result}'
 
     def assert_not_equal(self, expectant_expression, practical_result):
         expectant_result = self.parse_expectant_expression(expectant_expression)
         if isinstance(expectant_result, (int, float)) and isinstance(practical_result, str):
-            practical_result = eval(practical_result)
+            if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith(
+                    "}"):
+                practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
+            else:
+                practical_result = eval(practical_result)
         assert practical_result != expectant_result, f'{expectant_result} != {practical_result}'
+        return f'{expectant_result} != {practical_result}'
 
     def assert_less_than(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_digit(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result < practical_result, f'{expectant_result} < {practical_result}'
+        return f'{expectant_result} < {practical_result}'
 
     def assert_less_than_or_equals(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_digit(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result <= practical_result, f'{expectant_result} <= {practical_result}'
+        return f'{expectant_result} <= {practical_result}'
 
     def assert_greater_than(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_digit(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result > practical_result, f'{expectant_result} > {practical_result}'
+        return f'{expectant_result} > {practical_result}'
 
     def assert_greater_than_or_equals(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_digit(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result >= practical_result, f'{expectant_result} >= {practical_result}'
+        return f'{expectant_result} >= {practical_result}'
 
     def assert_contains(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert practical_result in expectant_result, f'{practical_result} in {expectant_result}'
+        return f'{practical_result} in {expectant_result}'
 
     def assert_contained_by(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result in practical_result, f'{expectant_result} in {practical_result}'
+        return f'{expectant_result} in {practical_result}'
 
     def assert_startswith(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result.startswith(practical_result), f'{expectant_result} 以 {practical_result} 开头'
+        return f'{expectant_result} 以 {practical_result} 开头'
 
     def assert_endswith(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert expectant_result.endswith(practical_result), f'{expectant_result} 以 {practical_result} 结尾'
+        return f'{expectant_result} 以 {practical_result} 结尾'
 
     def assert_length_equals(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert len(expectant_result) == int(practical_result), f'{len(expectant_result)} == {practical_result}'
+        return f'{len(expectant_result)} == {practical_result}'
 
     def assert_length_less_than(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert len(expectant_result) < int(practical_result), f'{len(expectant_result)} < {practical_result}'
+        return f'{len(expectant_result)} < {practical_result}'
 
     def assert_length_less_than_or_equals(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert len(expectant_result) <= int(practical_result), f'{len(expectant_result)} <= {practical_result}'
+        return f'{len(expectant_result)} <= {practical_result}'
 
     def assert_length_greater_than(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert len(expectant_result) > int(practical_result), f'{len(expectant_result)} > {practical_result}'
+        return f'{len(expectant_result)} > {practical_result}'
 
     def assert_length_greater_than_or_equals(self, expectant_expression, practical_result):
         expectant_result, practical_result = self.__to_str(
             self.parse_expectant_expression(expectant_expression),
             practical_result
         )
+        if isinstance(practical_result, str) and practical_result.startswith("${") and practical_result.endswith("}"):
+            practical_result = RenderData(self.data).get_attribute(practical_result[2:-1])
         assert len(expectant_result) >= int(practical_result), f'{len(expectant_result)} >= {practical_result}'
+        return f'{len(expectant_result)} >= {practical_result}'
+
+    def assert_is_null(self, expectant_expression, practical_result):
+        expectant_result = self.parse_expectant_expression(expectant_expression)
+        assert expectant_result is None
+        return expectant_result
+
+    def assert_is_not_null(self, expectant_expression, practical_result):
+        expectant_result = self.parse_expectant_expression(expectant_expression)
+        assert expectant_result is not None
+        return expectant_result
 
     def __to_str(self, expectant_expression, practical_result):
         if isinstance(expectant_expression, (int, float)):

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/pytest_api_framework_alpha.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-api-framework-alpha
-Version: 0.2.2
+Version: 0.2.3
 Author: alpha
 Author-email: 
 Requires-Python: >=3.6

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/pytest_api_framework_alpha.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ framework/global_attribute.py
 framework/http_client.py
 framework/render_data.py
 framework/report.py
+framework/settings.py
 framework/startapp.py
 framework/validate.py
 framework/db/__init__.py

{pytest_api_framework_alpha-0.2.2 → pytest_api_framework_alpha-0.2.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pytest-api-framework-alpha",  # 包名（必须唯一）
-    version="0.2.2",
+    version="0.2.3",
     packages=find_packages(),
     author="alpha",
     author_email="",