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

api_engine_xin-0.0.25/ApiEngine/BaseCase.py

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

api_engine_xin-0.0.25/ApiEngine/__init__.py

@@ -0,0 +1,3 @@
+from ApiEngine.infra.case_log import CaseLogHandler
+
+log = CaseLogHandler()

api_engine_xin-0.0.25/ApiEngine/core.py

@@ -0,0 +1,407 @@
+import copy
+
+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.engine.base_case import BaseCase
+
+
+class TestRunner:
+    def __init__(self, env_data):
+        """
+        :param env_data: 执行测试时的环境数据
+        """
+        # 深拷贝环境数据，避免修改调用方原始数据
+        self.env_data = copy.deepcopy(env_data)
+        # debug_updates 保持原引用，变更对上层可见
+        if "debug_updates" in env_data:
+            self.env_data["debug_updates"] = env_data["debug_updates"]
+        self.result = []
+        self._db = DBClient()
+        self._shared_env = {}  # 实例级共享环境
+
+    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)
+        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):
+        """执行单条用例"""
+        # 每次创建新的 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__)
+
+
+if __name__ == '__main__':
+    import os
+
+    # 获取测试辅助文件的绝对路径
+    _test_dir = os.path.join(os.path.dirname(__file__), '..', 'tests')
+    _setup = open(os.path.join(_test_dir, 'setup_scripts.txt'), 'r', encoding='utf-8').read()
+    _teardown = open(os.path.join(_test_dir, 'teardown_scripts.txt'), 'r', encoding='utf-8').read()
+    _tools = open(os.path.join(_test_dir, 'Tools.py'), 'r', encoding='utf-8').read()
+
+    test_case = {
+        "title": "登录成功",
+        "interface": {
+            "url": "/member/public/login",
+            "method": "post"
+        },
+        "headers": {
+            "Content-Type": "application/x-www-form-urlencoded"
+        },
+        "request": {
+            "data": {
+                "keywords": "13012341231",
+                "password": "test123"
+            }
+        },
+        "setup_script": _setup,
+        "teardown_script": "",
+        "extract": [
+            {"var_name": "status", "extract_expr": "$.status"},
+            {"var_name": "description", "extract_expr": "$.description"}
+        ],
+        "assertions": [
+            {"type": "相等", "field": "$.status", "expected": 200},
+            {"type": "相等", "field": "$.description", "expected": "登录成功"}
+        ]
+    }
+
+    test_case2 = {
+        "title": "验证是否登录成功",
+        "interface": {
+            "url": "/member/public/islogin",
+            "method": "post"
+        },
+        "headers": {},
+        "request": {
+            "params": {
+                "m": "Home",
+                "c": "User",
+                "a": "do_login",
+                "t": "${status}"
+            },
+        },
+        "preconditions": [
+            {
+                "title": "P2P登录成功",
+                "interface": {
+                    "url": "/member/public/login",
+                    "method": "post"
+                },
+                "headers": {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                },
+                "request": {
+                    "data": {
+                        "keywords": "13012341231",
+                        "password": "test123",
+                        "description": "${description3}"
+                    }
+                },
+                "setup_script": _setup,
+                "teardown_script": "",
+                "preconditions": [
+                    {
+                        "title": "验证当前用户没有登录",
+                        "interface": {
+                            "url": "/member/public/islogin",
+                            "method": "post"
+                        },
+                        "headers": {},
+                        "request": {},
+                        "setup_script": _setup,
+                        "teardown_script": "",
+                        "extract": [
+                            {"var_name": "status3", "extract_expr": "$.status"},
+                            {"var_name": "description3", "extract_expr": "$.description"}
+                        ],
+                        "assertions": [
+                            {"type": "相等", "field": "$.status", "expected": 200},
+                            {"type": "相等", "field": "$.description", "expected": "您未登陆！"}
+                        ]
+                    }
+                ],
+                "extract": [
+                    {"var_name": "status", "extract_expr": "$.status"},
+                    {"var_name": "description", "extract_expr": "$.description"}
+                ],
+                "assertions": [
+                    {"type": "相等", "field": "$.status", "expected": 200},
+                    {"type": "相等", "field": "$.description", "expected": "登录成功"}
+                ]
+            }
+        ],
+        "setup_script": _setup,
+        "teardown_script": "",
+        "extract": [
+            {"var_name": "status2", "extract_expr": "$.status"},
+            {"var_name": "description2", "extract_expr": "$.description"}
+        ],
+        "assertions": [
+            {"type": "相等", "field": "$.status", "expected": "${status3}"},
+            {"type": "相等", "field": "$.description", "expected": "OK"}
+        ]
+    }
+
+    test_suite = {
+        "name": "测试套件1",
+        "cases": [
+            {
+                "title": "登录接口",
+                "interface": {
+                    "url": "/member/public/login",
+                    "method": "post"
+                },
+                "headers": {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Token": "${token}"
+                },
+                "request": {
+                    "params": {},
+                    "data": {"keywords": "13012349900", "password": "test123",
+                             "user2": "${username}", "pwd2": "${password}",
+                             "mobile": "${mobile}"},
+                    "json": {"keywords": "13012349900", "password": "test123",
+                             "user2": "${username}", "pwd2": "${password}",
+                             "mobile": "${mobile}"}
+                },
+                "setup_script": _setup,
+                "teardown_script": _teardown
+            },
+            {
+                "title": "登录接口2",
+                "interface": {
+                    "url": "/member/public/login",
+                    "method": "post"
+                },
+                "headers": {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Token": "${token}"
+                },
+                "request": {
+                    "params": {},
+                    "data": {"keywords": "13012349900", "password": "test123",
+                             "user2": "${username}", "pwd2": "${password}",
+                             "mobile": "${mobile}"},
+                    "json": {"keywords": "13012349900", "password": "test123",
+                             "user2": "${username}", "pwd2": "${password}",
+                             "mobile": "${mobile}"}
+                },
+                "setup_script": _setup,
+                "teardown_script": ""
+            }
+        ]
+    }
+
+    test_suites = [
+        {
+            "name": "测试套件1",
+            "cases": [
+                {
+                    "title": "登录接口",
+                    "interface": {
+                        "url": "/member/public/login",
+                        "method": "post"
+                    },
+                    "headers": {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Token": "${token}"
+                    },
+                    "request": {
+                        "params": {},
+                        "data": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"},
+                        "json": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"}
+                    },
+                    "setup_script": _setup,
+                    "teardown_script": _teardown
+                },
+                {
+                    "title": "登录接口2",
+                    "interface": {
+                        "url": "/member/public/login",
+                        "method": "post"
+                    },
+                    "headers": {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Token": "${token}"
+                    },
+                    "request": {
+                        "params": {},
+                        "data": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"},
+                        "json": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"}
+                    },
+                    "setup_script": _setup,
+                    "teardown_script": ""
+                }
+            ]
+        },
+        {
+            "name": "测试套件2",
+            "cases": [
+                {
+                    "title": "登录接口3",
+                    "interface": {
+                        "url": "/member/public/login",
+                        "method": "post"
+                    },
+                    "headers": {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Token": "${token}"
+                    },
+                    "request": {
+                        "params": {},
+                        "data": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"},
+                        "json": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"}
+                    },
+                    "setup_script": _setup,
+                    "teardown_script": _teardown
+                },
+                {
+                    "title": "登录接口4",
+                    "interface": {
+                        "url": "/member/public/login",
+                        "method": "post"
+                    },
+                    "headers": {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        "Token": "${token}"
+                    },
+                    "request": {
+                        "params": {},
+                        "data": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"},
+                        "json": {"keywords": "13012349900", "password": "test123",
+                                 "user2": "${username}", "pwd2": "${password}",
+                                 "mobile": "${mobile}"}
+                    },
+                    "setup_script": _setup,
+                    "teardown_script": ""
+                }
+            ]
+        }
+    ]
+
+    # 全局环境数据
+    test_env_data = {
+        "base_url": "http://121.43.169.97:8081",
+        "headers": {
+            "Content-Type": "application/json"
+        },
+        "envs": {
+            "username": "rand_13012349900",
+            "password": "rand_test123",
+            "token": "12345678"
+        },
+        "global_func": _tools,
+        "db": [
+            {
+                "name": "P2P",
+                "type": "mysql",
+                "config": {
+                    "host": "121.43.169.97",
+                    "port": 3306,
+                    "user": "student",
+                    "password": "P2P_student_2023"
+                }
+            }
+        ]
+    }
+
+    runner = TestRunner(test_env_data)
+    result = runner.execute_cases(test_case2)
+    log.info_log("测试结果：", result)

api_engine_xin-0.0.25/ApiEngine/engine/__init__.py

@@ -0,0 +1 @@
+# ApiEngine 用例执行引擎层

api_engine_xin-0.0.25/ApiEngine/engine/assertion.py

@@ -0,0 +1,108 @@
+import re
+
+
+class AssertionEngine:
+    """断言引擎：支持中英文关键字、智能类型归一化"""
+
+    METHOD_MAP = {
+        # 相等
+        "相等": lambda a, b: a == b,
+        "equals": lambda a, b: a == b,
+        "eq": lambda a, b: a == b,
+        "==": lambda a, b: a == b,
+        # 相等忽略大小写
+        "相等忽略大小写": lambda a, b: a.lower() == b.lower(),
+        "equals_ignore_case": lambda a, b: a.lower() == b.lower(),
+        "eq_ignore_case": lambda a, b: a.lower() == b.lower(),
+        # 不相等
+        "不相等": lambda a, b: a != b,
+        "not_equals": lambda a, b: a != b,
+        "ne": lambda a, b: a != b,
+        "!=": lambda a, b: a != b,
+        # 包含
+        "包含": lambda a, b: a in b,
+        "contains": lambda a, b: a in b,
+        "in": lambda a, b: a in b,
+        # 不包含
+        "不包含": lambda a, b: a not in b,
+        "not_contains": lambda a, b: a not in b,
+        "not_in": lambda a, b: a not in b,
+        # 大于
+        "大于": lambda a, b: a > b,
+        "greater_than": lambda a, b: a > b,
+        "gt": lambda a, b: a > b,
+        ">": lambda a, b: a > b,
+        # 小于
+        "小于": lambda a, b: a < b,
+        "less_than": lambda a, b: a < b,
+        "lt": lambda a, b: a < b,
+        "<": lambda a, b: a < b,
+        # 大于等于
+        "大于等于": lambda a, b: a >= b,
+        "greater_than_or_equals": lambda a, b: a >= b,
+        "ge": lambda a, b: a >= b,
+        ">=": lambda a, b: a >= b,
+        # 小于等于
+        "小于等于": lambda a, b: a <= b,
+        "less_than_or_equals": lambda a, b: a <= b,
+        "le": lambda a, b: a <= b,
+        "<=": lambda a, b: a <= b,
+        # 正则匹配
+        "正则匹配": lambda a, b: re.search(a, b),
+        "regex_match": lambda a, b: re.search(a, b),
+        "regex": lambda a, b: re.search(a, b),
+        "match": lambda a, b: re.search(a, b),
+    }
+
+    @staticmethod
+    def _normalize_for_compare(expect, actual):
+        """
+        智能类型归一化，解决 str/int/float 类型不一致导致的断言失败
+        """
+        if type(expect) == type(actual):
+            return expect, actual
+
+        try:
+            if isinstance(actual, (int, float)) and isinstance(expect, str):
+                if '.' in str(expect):
+                    return float(expect), actual
+                else:
+                    return int(expect), actual
+            elif isinstance(expect, (int, float)) and isinstance(actual, str):
+                if '.' in str(actual):
+                    return expect, float(actual)
+                else:
+                    return expect, int(actual)
+        except (ValueError, TypeError):
+            pass
+
+        return expect, actual
+
+    @classmethod
+    def assert_value(cls, method, expect, actual, debug_log=None, info_log=None, error_log=None):
+        """
+        执行断言
+        :param method: 断言比较方式
+        :param expect: 预期结果
+        :param actual: 实际结果
+        """
+        expect, actual = cls._normalize_for_compare(expect, actual)
+
+        assert_fun = cls.METHOD_MAP.get(method)
+        if assert_fun is None:
+            raise Exception("不支持的断言方法")
+        else:
+            if debug_log:
+                debug_log(f"断言比较方法是：{method}")
+                debug_log(f"预期结果是：{expect}")
+                debug_log(f"实际结果是：{actual}")
+        try:
+            assert assert_fun(expect, actual)
+        except AssertionError:
+            msg = f"断言失败，实际结果({actual}) 不满足({method}) 期望结果({expect})"
+            if error_log:
+                error_log(msg)
+            raise AssertionError(msg)
+        else:
+            if info_log:
+                info_log(f"断言成功，实际结果({actual}) 满足({method}) 期望结果({expect})")