api-engine-xin 0.0.26__tar.gz → 0.0.29__tar.gz

api_engine_xin-0.0.29/ApiEngine/core.py

@@ -0,0 +1,195 @@
+import copy
+from typing import Optional
+
+from ApiEngine import log
+from ApiEngine.infra import global_func
+from ApiEngine.engine.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, run_id=None):
+        """
+        :param env_data: 执行测试时的环境数据
+        :param run_id: 套件运行ID（传入时启用套件级变量共享）
+        """
+        # 深拷贝环境数据，避免修改调用方原始数据
+        self.env_data = copy.deepcopy(env_data)
+        # 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):
+        """执行测试用例的方法"""
+        # 根据数据库的配置初始化数据库的连接
+        db_config = self.env_data.pop("db", None)
+        if db_config:
+            self._db.init_connect(db_config)
+
+        # 统一初始化共享环境
+        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._shared_env["_run_store"] = self._suite_store  # 供 BaseCase 心跳 touch
+
+        self._load_global_func()
+
+        # 判断测试数据参数的类型
+        if isinstance(testcases, dict):
+            cases = testcases.get("cases")
+            if cases:
+                log.info_log("执行测试套件：", testcases["name"])
+                test_result = TestResult(all=len(testcases["cases"]), name=testcases["name"])
+                for case in testcases["cases"]:
+                    log.info_log(case)
+                    self.perform_case(case, test_result)
+                res = test_result.get_result_info()
+                self.result.append(res)
+            else:
+                log.info_log("调试单条接口用例：", testcases["title"])
+                test_result = TestResult(all=1)
+                self.perform_case(testcases, test_result)
+                res = test_result.get_result_info()
+                self.result = res["cases"][0]
+        elif isinstance(testcases, list):
+            results = []
+            for items in testcases:
+                log.info_log("执行测试套件：", items["name"])
+                test_result = TestResult(all=len(items["cases"]), name=items["name"])
+                for case in items["cases"]:
+                    self.perform_case(case, test_result)
+                res = test_result.get_result_info()
+                results.append(res)
+            total_all = 0
+            total_success = 0
+            total_fail = 0
+            total_error = 0
+            for scence_result in results:
+                total_all += scence_result["all"]
+                total_success += scence_result["success"]
+                total_fail += scence_result["fail"]
+                total_error += scence_result["error"]
+            self.result = {
+                "results": results,
+                "all": total_all,
+                "success": total_success,
+                "fail": total_fail,
+                "error": total_error
+            }
+        else:
+            log.error_log("测试数据格式错误")
+
+        # 断开数据库连接
+        if db_config:
+            self._db.close_db_connect()
+        return self.result
+
+    def perform_case(self, case, test_result):
+        """执行单条用例"""
+        # 心跳：每开始一条用例就刷新活跃时间，防止长套件被 cleanup 误清
+        if self._run_id:
+            RunRegistry.touch(self._run_id)
+        # 每次创建新的 BaseCase 实例，传入共享环境引用
+        c = BaseCase(shared_env=self._shared_env)
+        c._db = self._db
+        try:
+            c.perform(case)
+        except PreconditionChainError:
+            test_result.add_fail(c)
+        except AssertionError:
+            test_result.add_fail(c)
+        except Exception as e:
+            test_result.add_error(c, e)
+        else:
+            test_result.add_success(c)
+
+    def _load_global_func(self):
+        """安全加载用户自定义函数，避免跨执行污染"""
+        _gf = self.env_data.get("global_func")
+        if not (_gf and isinstance(_gf, str)):
+            return
+        # 只保留 __name__ 等双下划线内置属性
+        builtins = {k: v for k, v in global_func.__dict__.items() if k.startswith('__')}
+        global_func.__dict__.clear()
+        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)

{api_engine_xin-0.0.26 → api_engine_xin-0.0.29}/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()
@@ -244,8 +255,18 @@ class BaseCase(CaseLogHandler):
 
     # ==================== 环境变量操作 ====================
 
+    def _touch_store(self):
+        """心跳：刷新 RunStore 活跃时间，防止长运行被误清"""
+        try:
+            run_store = self._shared_env.get("_run_store")
+            if run_store:
+                run_store.touch()
+        except Exception:
+            pass
+
     def _save_env_variable(self, key, value):
         """保存临时环境变量"""
+        self._touch_store()
         self.info_log(f"保存（临时）环境变量：{key} = {value}")
         self.env[key] = value
         try:
@@ -261,11 +282,20 @@ class BaseCase(CaseLogHandler):
 
     def del_evn_variable(self, key):
         """删除测试运行环境变量"""
+        self._touch_store()
         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):
         """保存测试运行环境的全局变量"""
+        self._touch_store()
         self.info_log(f"保存全局变量：{key} = {value}")
         envs = self._shared_env.get("envs")
         if isinstance(envs, dict):
@@ -280,6 +310,7 @@ class BaseCase(CaseLogHandler):
 
     def del_global_variable(self, key):
         """删除测试运行环境的全局变量"""
+        self._touch_store()
         self.info_log(f"删除全局变量：{key}")
         envs = self._shared_env.get("envs")
         if isinstance(envs, dict) and key in envs:

{api_engine_xin-0.0.26 → api_engine_xin-0.0.29}/ApiEngine/engine/precondition.py

@@ -1,4 +1,4 @@
-from ApiEngine.infra.exceptions import PreconditionChainError
+from ApiEngine.engine.exceptions import PreconditionChainError
 from ApiEngine.http.client import HttpClient
 from ApiEngine.engine.script_runner import ScriptRunner
 from ApiEngine.engine.extractor import Extractor
@@ -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.26 → api_engine_xin-0.0.29}/ApiEngine/infra/__init__.py

@@ -1,3 +1,2 @@
 # ApiEngine 基础设施层
 from ApiEngine.infra.case_log import CaseLogHandler
-from ApiEngine.infra.exceptions import PreconditionChainError

api_engine_xin-0.0.29/ApiEngine/infra/suite_store.py

@@ -0,0 +1,98 @@
+"""套件级共享变量存储（跨 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:     注册时间戳（仅用于诊断日志）
+    last_active_at: 最后一次变量读写的时间戳（cleanup 依据）
+    """
+    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)
+    last_active_at: float = field(default_factory=time.time)
+
+    def touch(self) -> None:
+        """刷新活跃时间，防止长运行套件被 cleanup_stale 误清。"""
+        self.last_active_at = 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 touch(cls, run_id: str) -> None:
+        """刷新指定运行的活跃时间。变量读写时调用。"""
+        store = cls._stores.get(run_id)
+        if store:
+            store.touch()
+
+    @classmethod
+    def cleanup_stale(cls, max_age_seconds: float = 3600) -> int:
+        """清理超时的残留 store（防止异常中断导致内存泄漏）。
+
+        依据 last_active_at（最后一次变量读写）而非 created_at，
+        因此长时间运行但仍在活跃的套件不会被误清。
+
+        :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.last_active_at > max_age_seconds
+            ]
+            for rid in stale:
+                cls._stores.pop(rid, None)
+            return len(stale)