api-engine-xin 0.0.25__tar.gz → 0.0.28__tar.gz

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/ApiEngine/core.py

@@ -1,26 +1,31 @@
 import copy
+from typing import Optional
 
 from ApiEngine import log
 from ApiEngine.infra import global_func
 from ApiEngine.infra.exceptions import PreconditionChainError
 from ApiEngine.infra.test_result import TestResult
 from ApiEngine.infra.db_client import DBClient
+from ApiEngine.infra.suite_store import RunRegistry, RunStore
 from ApiEngine.engine.base_case import BaseCase
 
 
 class TestRunner:
-    def __init__(self, env_data):
+    def __init__(self, env_data, run_id=None):
         """
         :param env_data: 执行测试时的环境数据
+        :param run_id: 套件运行ID（传入时启用套件级变量共享）
         """
         # 深拷贝环境数据，避免修改调用方原始数据
         self.env_data = copy.deepcopy(env_data)
-        # debug_updates 保持原引用，变更对上层可见
+        # debug_updates 保持原引用，变更对上层可见（仅无 run_id 的退化路径使用）
         if "debug_updates" in env_data:
             self.env_data["debug_updates"] = env_data["debug_updates"]
         self.result = []
         self._db = DBClient()
         self._shared_env = {}  # 实例级共享环境
+        self._run_id = run_id
+        self._suite_store: Optional[RunStore] = RunRegistry.get(run_id) if run_id else None
 
     def execute_cases(self, testcases):
         """执行测试用例的方法"""
@@ -32,6 +37,13 @@ class TestRunner:
         # 统一初始化共享环境
         self._shared_env.clear()
         self._shared_env.update(self.env_data)
+
+        # 如果有 run_id，将 _shared_env["envs"] 和 debug_updates 指向套件级存储
+        # 这样所有变量读写（包括 Replacer、用户脚本、前置用例提取）自动走 _suite_stores
+        if self._suite_store:
+            self._shared_env["envs"] = self._suite_store.envs
+            self._shared_env["debug_updates"] = self._suite_store.debug_updates
+
         self._load_global_func()
 
         # 判断测试数据参数的类型
@@ -111,6 +123,73 @@ class TestRunner:
         global_func.__dict__.update(builtins)
         exec(_gf, global_func.__dict__)
 
+    def get_env_snapshot(self) -> dict:
+        """获取执行后的环境变量快照（供上层平台读取）
+
+        返回包含 envs、debug_updates 的字典，
+        用于上层平台同步临时变量和持久化全局变量变更。
+
+        debug_updates 中的约定：
+        - value 非 None → 新增/更新全局变量
+        - value 为 None → 删除全局变量
+        """
+        return {
+            "envs": copy.deepcopy(dict(self._shared_env.get("envs") or {})),
+            "debug_updates": copy.deepcopy(self._shared_env.get("debug_updates") or {}),
+        }
+
+    # ==================== 套件级共享变量：生命周期管理 ====================
+
+    @classmethod
+    def register_run(cls, run_id: str, initial_envs: dict) -> None:
+        """套件开始前注册共享存储。
+
+        :param run_id: 唯一运行标识（建议格式: suite-{id}-{run_id}-{timestamp}）
+        :param initial_envs: 初始环境变量（用户配置的基线值，含 DB 全局变量）
+        """
+        RunRegistry.register(run_id, initial_envs)
+
+    @classmethod
+    def unregister_run(cls, run_id: str) -> None:
+        """套件结束后清理共享存储。务必在 finally 中调用。"""
+        RunRegistry.unregister(run_id)
+
+    @classmethod
+    def get_debug_updates(cls, run_id: str) -> dict:
+        """获取需要持久化到 DB 的全局变量变更队列。
+
+        返回 dict 副本：
+        - value 非 None → upsert
+        - value 为 None → delete
+        """
+        store = RunRegistry.get(run_id)
+        if not store:
+            return {}
+        with store.lock:
+            return dict(store.debug_updates)
+
+    @classmethod
+    def clear_debug_updates(cls, run_id: str) -> None:
+        """重置变更队列（平台写 DB 后调用，避免重复写入）。"""
+        store = RunRegistry.get(run_id)
+        if store:
+            with store.lock:
+                store.debug_updates.clear()
+
+    @classmethod
+    def get_run_globals(cls, run_id: str) -> dict:
+        """获取当前套件累积的全部环境变量（含初始基线 + 运行时设置）。"""
+        store = RunRegistry.get(run_id)
+        if not store:
+            return {}
+        with store.lock:
+            return dict(store.envs)
+
+    @classmethod
+    def cleanup_stale_runs(cls, max_age_seconds: float = 3600) -> None:
+        """清理超时的残留 store（防止异常中断导致内存泄漏）。"""
+        RunRegistry.cleanup_stale(max_age_seconds)
+
 
 if __name__ == '__main__':
     import os

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/ApiEngine/engine/base_case.py

@@ -41,9 +41,13 @@ class BaseCase(CaseLogHandler):
 
     # ==================== HTTP 请求 ====================
 
-    def _send_request(self, data):
+    def _send_request(self, data, http_client=None):
         """构建并发送请求"""
-        http_client = HttpClient()
+        if http_client is None:
+            http_client = HttpClient()
+            self._owns_http_client = True
+        else:
+            self._owns_http_client = False
         self._http_client = http_client
         replacer = Replacer(self._shared_env, self.env, self.info_log)
         request_data = http_client.build_request(data, self._shared_env, replacer)
@@ -182,12 +186,18 @@ class BaseCase(CaseLogHandler):
         self._assert_results = []
         case_name = data.get('title')
         has_failure = False
+        shared_http_client = None
 
         try:
+            # 创建共享 HTTP session（前置步骤 + 主用例共用 Cookie）
+            shared_http_client = HttpClient()
+
             # 1、前置条件链
             if data.get("preconditions"):
                 self.info_log("========== 开始执行前置步骤链 ==========")
-                precond_executor = PreconditionExecutor(self._shared_env, self._db)
+                precond_executor = PreconditionExecutor(
+                    self._shared_env, self._db, http_client=shared_http_client
+                )
                 self._precondition_errors, self._precondition_results = precond_executor.execute(
                     data.get("preconditions"), depth=1, log_handler=self
                 )
@@ -203,7 +213,7 @@ class BaseCase(CaseLogHandler):
             # 2、前置脚本 + 发送请求
             self.info_log(f"开始执行用例步骤:{case_name}")
             self._setup_script(data)
-            response = self._send_request(data)
+            response = self._send_request(data, http_client=shared_http_client)
 
             # 3、数据提取
             if data.get("extract"):
@@ -232,9 +242,10 @@ class BaseCase(CaseLogHandler):
             raise
 
         finally:
-            # 关闭 http client
+            # 关闭共享 http client
+            if shared_http_client:
+                shared_http_client.close()
             if hasattr(self, '_http_client'):
-                self._http_client.close()
                 delattr(self, '_http_client')
 
             end_time = time.time()
@@ -262,7 +273,14 @@ class BaseCase(CaseLogHandler):
     def del_evn_variable(self, key):
         """删除测试运行环境变量"""
         self.info_log(f"删除（临时）环境变量：{key}")
-        del self.env[key]
+        self.env.pop(key, None)
+        # 同时从套件级共享存储中删除，防止后续用例读到已删除的变量
+        try:
+            envs = self._shared_env.get("envs")
+            if isinstance(envs, dict):
+                envs.pop(key, None)
+        except Exception:
+            pass
 
     def save_global_variable(self, key, value):
         """保存测试运行环境的全局变量"""
@@ -284,11 +302,11 @@ class BaseCase(CaseLogHandler):
         envs = self._shared_env.get("envs")
         if isinstance(envs, dict) and key in envs:
             del envs[key]
-        # 从 debug_updates 中移除，上层不再同步该变量到DB
+        # 在 debug_updates 中标记为 None，通知上层从数据库删除
         try:
             debug_updates = self._shared_env.get("debug_updates")
-            if isinstance(debug_updates, dict) and key in debug_updates:
-                del debug_updates[key]
+            if isinstance(debug_updates, dict):
+                debug_updates[key] = None
         except Exception:
             pass
 

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/ApiEngine/engine/precondition.py

@@ -8,11 +8,12 @@ from ApiEngine.engine.assertion import AssertionEngine
 class PreconditionExecutor:
     """前置条件递归执行器（深度优先 DFS）"""
 
-    def __init__(self, shared_env, db):
+    def __init__(self, shared_env, db, http_client=None):
         self._shared_env = shared_env
         self._db = db
         self._extractor = Extractor()
         self._precondition_results = []
+        self._shared_http_client = http_client  # 共享 HTTP session
 
     def execute(self, steps, depth=1, failure_mode="continue", log_handler=None):
         """
@@ -47,6 +48,7 @@ class PreconditionExecutor:
 
             # 单步执行
             step_error = None
+            has_assertion_error = False
             response = None
             step_assert_results = []
             step_extract_results = []
@@ -65,9 +67,12 @@ class PreconditionExecutor:
                 )
                 next(script_hook)
 
-                # 发送请求
+                # 发送请求：使用共享 session，无共享则创建临时实例
                 from ApiEngine.engine.replacer import Replacer
-                http_client = HttpClient()
+                if self._shared_http_client:
+                    http_client = self._shared_http_client
+                else:
+                    http_client = HttpClient()
                 temp_env = {}
                 replacer = Replacer(self._shared_env, temp_env, log_handler.info_log)
                 request_data = http_client.build_request(step, self._shared_env, replacer)
@@ -180,6 +185,13 @@ class PreconditionExecutor:
                         log_handler.info_log(f"{prefix}  断言汇总：{total} 个全部通过 ✅")
 
             except AssertionError as e:
+                has_assertion_error = True
+                step_error = {
+                    "level": depth,
+                    "step_title": title,
+                    "error_type": "ASSERTION_FAILED",
+                    "message": str(e)
+                }
                 log_handler.warning_log(f"{prefix}❌ [L{depth}] 存在断言失败: {title} — {e}")
 
             except Exception as e:
@@ -199,8 +211,8 @@ class PreconditionExecutor:
                     except StopIteration:
                         pass
 
-                # 关闭 http client
-                if http_client:
+                # 仅关闭非共享的 http client
+                if http_client and not self._shared_http_client:
                     http_client.close()
 
                 # 构建步骤结果
@@ -213,8 +225,16 @@ class PreconditionExecutor:
                         _elapsed = "{} ms".format(int(response.elapsed.total_seconds() * 1000))
                     except Exception:
                         pass
+                # 推断步骤状态
+                if step_error:
+                    step_status = "fail"
+                elif has_assertion_error:
+                    step_status = "fail"
+                else:
+                    step_status = "success"
                 step_result = {
                     "title": title,
+                    "status": step_status,
                     "status_code": getattr(log_handler, 'status_code', ''),
                     "response_headers": dict(getattr(log_handler, 'response_headers', {}) or {}),
                     "response_body": getattr(log_handler, 'response_body', ''),
@@ -227,7 +247,10 @@ class PreconditionExecutor:
                     "extract_info": list(step_extract_results),
                 }
                 self._precondition_results.append(step_result)
-                log_handler.info_log(f"{prefix}✅ [L{depth}] 前置完成: {title}")
+                if step_error or has_assertion_error:
+                    log_handler.warning_log(f"{prefix}❌ [L{depth}] 前置失败: {title}")
+                else:
+                    log_handler.info_log(f"{prefix}✅ [L{depth}] 前置完成: {title}")
 
             # 根据 failure_mode 决定是否继续
             if step_error:

api_engine_xin-0.0.28/ApiEngine/infra/suite_store.py

@@ -0,0 +1,82 @@
+"""套件级共享变量存储（跨 TestRunner 实例）。
+
+设计目的：
+  同一个套件内的多个用例各自创建独立的 TestRunner 实例，
+  但需要共享变量（save_env_variable / save_global_variable 设置的值）。
+  本模块提供类级别的注册表，用 run_id 关联同一套件的所有实例。
+
+线程安全：
+  所有 dict 写操作通过 threading.Lock 保护，支持并行用例场景。
+
+生命周期：
+  平台层在套件开始前调用 register_run()，结束后调用 unregister_run()。
+  cleanup_stale() 兜底清理异常中断导致的残留。
+"""
+
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Set
+
+
+@dataclass
+class RunStore:
+    """单次套件运行的共享变量存储。
+
+    envs:          套件级累积环境变量（含初始基线 + 运行中写入）
+    debug_updates: 需要持久化到 DB 的全局变量变更队列
+    temp_keys:     标记哪些 key 是 save_env_variable 写入的（区分 temp 与 global）
+    lock:          保护并发写操作
+    created_at:    注册时间戳（用于 TTL 清理）
+    """
+    envs: dict = field(default_factory=dict)
+    debug_updates: dict = field(default_factory=dict)
+    temp_keys: Set[str] = field(default_factory=set)
+    lock: threading.Lock = field(default_factory=threading.Lock)
+    created_at: float = field(default_factory=time.time)
+
+
+class RunRegistry:
+    """类级别注册表：run_id → RunStore。
+
+    串行场景：后续用例可读到前面用例设置的变量。
+    并行场景：lock 保护 dict 操作，last-write-wins。
+    """
+    _stores: Dict[str, RunStore] = {}
+    _registry_lock = threading.Lock()
+
+    @classmethod
+    def register(cls, run_id: str, initial_envs: dict) -> RunStore:
+        """注册套件运行，创建共享存储。"""
+        with cls._registry_lock:
+            store = RunStore(envs=dict(initial_envs or {}))
+            cls._stores[run_id] = store
+            return store
+
+    @classmethod
+    def get(cls, run_id: str) -> Optional[RunStore]:
+        """获取指定运行的共享存储。"""
+        return cls._stores.get(run_id)
+
+    @classmethod
+    def unregister(cls, run_id: str) -> None:
+        """清理指定运行的共享存储。务必在 finally 中调用。"""
+        with cls._registry_lock:
+            cls._stores.pop(run_id, None)
+
+    @classmethod
+    def cleanup_stale(cls, max_age_seconds: float = 3600) -> int:
+        """清理超时的残留 store（防止异常中断导致内存泄漏）。
+
+        :param max_age_seconds: 超时阈值（秒），默认1小时
+        :return: 清理数量
+        """
+        now = time.time()
+        with cls._registry_lock:
+            stale = [
+                rid for rid, s in cls._stores.items()
+                if now - s.created_at > max_age_seconds
+            ]
+            for rid in stale:
+                cls._stores.pop(rid, None)
+            return len(stale)

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: api_engine_xin
-Version: 0.0.25
+Version: 0.0.28
 Summary: 接口测试平台测试用例执行引擎
 Home-page: https://pypi.org/project/api_engine_xin/
 Author: Shawn

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/api_engine_xin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: api-engine-xin
-Version: 0.0.25
+Version: 0.0.28
 Summary: 接口测试平台测试用例执行引擎
 Home-page: https://pypi.org/project/api_engine_xin/
 Author: Shawn

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/api_engine_xin.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 setup.py
-ApiEngine/BaseCase.py
 ApiEngine/__init__.py
 ApiEngine/core.py
 ApiEngine/engine/__init__.py
@@ -19,6 +18,7 @@ ApiEngine/infra/case_log.py
 ApiEngine/infra/db_client.py
 ApiEngine/infra/exceptions.py
 ApiEngine/infra/global_func.py
+ApiEngine/infra/suite_store.py
 ApiEngine/infra/test_result.py
 api_engine_xin.egg-info/PKG-INFO
 api_engine_xin.egg-info/SOURCES.txt

{api_engine_xin-0.0.25 → api_engine_xin-0.0.28}/setup.py

@@ -9,7 +9,7 @@ with codecs.open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
 
 setup(
     name="api_engine_xin",
-    version="0.0.25",
+    version="0.0.28",
     author="Shawn",
     author_email="xiaoh0525@xiaoh.com",
     description="接口测试平台测试用例执行引擎",

api_engine_xin-0.0.25/ApiEngine/BaseCase.py

@@ -1,2 +0,0 @@
-# 向后兼容层 — 旧代码可通过 from ApiEngine.BaseCase import BaseCase 导入
-from ApiEngine.engine.base_case import BaseCase