yaml-test-core 1.0.0__tar.gz

yaml_test_core-1.0.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2026 yaml-test-core
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yaml_test_core-1.0.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: yaml-test-core
+Version: 1.0.0
+Summary: YAML DSL test runtime core
+Author-email: Your Name <xxx@xxx.com>
+Project-URL: Repository, https://github.com/cuidingyong/yaml_test_core
+Project-URL: Issues, https://github.com/cuidingyong/yaml_test_core/issues
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: allure-pytest>=2.16.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jsonpath-ng>=1.8.0
+Requires-Dist: pydantic>=2.13.4
+Dynamic: license-file
+
+# yaml-test-core
+
+[![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Status](https://img.shields.io/badge/status-release-brightgreen)]()
+
+YAML 自动化测试框架内核，轻量、高可扩展、纯异步接口测试运行时。
+
+专为**接口自动化测试、yaml 用例驱动、动态表达式、自定义工具、Allure 可视化报告**设计。
+
+## ✨ 核心特性
+
+- 🚀 **全异步执行引擎**
+  基于 asyncio 实现，接口请求、表达式渲染、工具调用全部异步化
+- 📄 **纯 YAML 用例驱动**
+  零代码编写接口自动化，用例结构清晰易维护
+- 🧩 **强大表达式引擎**
+  支持 `${var}` 变量渲染、JSONPath、自定义工具函数调用
+- 🔧 **可注册自定义工具**
+  支持同步/异步工具注册，业务高度可扩展
+- 📊 **完整 Allure 报告**
+  自动生成步骤层级、执行日志、断言详情、失败附件
+- 🔁 **原生循环步骤支持**
+  内置 Loop 步骤、break_loop、跳过机制
+- ✅ **软硬断言体系**
+  支持批量断言、软断言不中断、失败兜底策略
+- 🧼 **完整上下文隔离**
+  步骤上下文、循环子上下文自动克隆隔离
+
+## 📦 安装
+
+```bash
+pip install yaml-test-core

yaml_test_core-1.0.0/README.md

@@ -0,0 +1,33 @@
+# yaml-test-core
+
+[![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Status](https://img.shields.io/badge/status-release-brightgreen)]()
+
+YAML 自动化测试框架内核，轻量、高可扩展、纯异步接口测试运行时。
+
+专为**接口自动化测试、yaml 用例驱动、动态表达式、自定义工具、Allure 可视化报告**设计。
+
+## ✨ 核心特性
+
+- 🚀 **全异步执行引擎**
+  基于 asyncio 实现，接口请求、表达式渲染、工具调用全部异步化
+- 📄 **纯 YAML 用例驱动**
+  零代码编写接口自动化，用例结构清晰易维护
+- 🧩 **强大表达式引擎**
+  支持 `${var}` 变量渲染、JSONPath、自定义工具函数调用
+- 🔧 **可注册自定义工具**
+  支持同步/异步工具注册，业务高度可扩展
+- 📊 **完整 Allure 报告**
+  自动生成步骤层级、执行日志、断言详情、失败附件
+- 🔁 **原生循环步骤支持**
+  内置 Loop 步骤、break_loop、跳过机制
+- ✅ **软硬断言体系**
+  支持批量断言、软断言不中断、失败兜底策略
+- 🧼 **完整上下文隔离**
+  步骤上下文、循环子上下文自动克隆隔离
+
+## 📦 安装
+
+```bash
+pip install yaml-test-core

yaml_test_core-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yaml-test-core"
+version = "1.0.0"
+description = "YAML DSL test runtime core"
+readme = "README.md"
+license-files = [ "LICENSE" ]
+authors = [
+  { name = "Your Name", email = "xxx@xxx.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "allure-pytest>=2.16.0",
+    "httpx>=0.28.1",
+    "jsonpath-ng>=1.8.0",
+    "pydantic>=2.13.4",
+]
+classifiers = [
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+"Repository" = "https://github.com/cuidingyong/yaml_test_core"
+"Issues" = "https://github.com/cuidingyong/yaml_test_core/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

yaml_test_core-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yaml_test_core-1.0.0/src/yaml_test_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

yaml_test_core-1.0.0/src/yaml_test_core/core/__init__.py

@@ -0,0 +1,81 @@
+from .assertion import (
+    AssertionExecutor,
+    AssertParser,
+    SoftAssertor
+)
+from .context import (
+    ContextProtocol,
+    TestContext,
+    EvalContextProxy,
+)
+from .exceptions import (
+    FrameworkBaseError,
+    ContextIndexError,
+    ExtractorParseError,
+    SkipSignal,
+    BreakLoopSignal,
+    RenderError,
+    StepTypeError,
+)
+from .expression import ExpressionEngine, RenderMode
+from .extractor import Extractor
+from .model import (
+    TestCase,
+    BaseStepType,
+    Step,
+    LoopStep,
+    Fragment,
+    OnFailure,
+    BreakLoopMode,
+    ApiInstanceFactoryProtocol,
+    SkipMode,
+    StepData
+)
+from .protocol import ToolRegistryProtocol
+from .step_runner import StepRunner
+
+__all__ = [
+    "FrameworkBaseError",
+    "ContextIndexError",
+    "ExtractorParseError",
+    "SkipSignal",
+    "BreakLoopSignal",
+    "RenderError",
+    "StepTypeError",
+
+    # context
+    "ContextProtocol",
+    "TestContext",
+    "EvalContextProxy",
+
+    # assert
+    "SoftAssertor",
+    "AssertionExecutor",
+    "AssertParser",
+
+    # expression
+    "ExpressionEngine",
+    "RenderMode",
+
+    # extractor
+    "Extractor",
+
+    # enums
+    "SkipMode",
+    "BreakLoopMode",
+
+    # model & protocol
+    "TestCase",
+    "Step",
+    "LoopStep",
+    "OnFailure",
+    "StepData",
+    "ApiInstanceFactoryProtocol",
+
+    # runner entrypoint
+    "StepRunner",
+
+    "ToolRegistry",
+]
+
+from .tool_registry import ToolRegistry

yaml_test_core-1.0.0/src/yaml_test_core/core/assertion/__init__.py

@@ -0,0 +1,9 @@
+from .assert_excutor import AssertionExecutor
+from .assert_parser import AssertParser
+from .assertor import SoftAssertor
+
+__all__ = [
+    'AssertionExecutor',
+    'AssertParser',
+    'SoftAssertor',
+]

yaml_test_core-1.0.0/src/yaml_test_core/core/assertion/assert_excutor.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+import allure
+
+from .assert_parser import AssertParser
+from .assertor import SoftAssertor
+
+
+class AssertionExecutor:
+    """
+    内核断言执行器
+    """
+
+    def __init__(self, soft_assertor: SoftAssertor, assert_parser: AssertParser):
+        self.soft: SoftAssertor = soft_assertor
+        self.parser: AssertParser = assert_parser
+
+    async def execute(self, response, base_expect, data_assert) -> tuple[Optional[str], Optional[str]]:
+        """
+        :return: (success_messages, fail_messages)
+        """
+        self.soft.clear_all()
+
+        if response and base_expect:
+            await self.parser.check_base_expect(response, base_expect)
+        if data_assert:
+            await self.parser.check_data_assert(response, data_assert)
+
+        success_msg = self.soft.get_all_msg(msg_type=1)
+        fail_msg = self.soft.get_all_msg(msg_type=2)
+
+        if success_msg:
+            allure.attach(success_msg, "成功断言明细", allure.attachment_type.TEXT)
+        if fail_msg:
+            allure.attach(fail_msg, "失败断言明细", allure.attachment_type.TEXT)
+
+        return success_msg, fail_msg
+
+    def clear(self) -> None:
+        self.soft.clear_all()

yaml_test_core-1.0.0/src/yaml_test_core/core/assertion/assert_parser.py

@@ -0,0 +1,193 @@
+import re
+from typing import Optional, Any
+
+import jsonpath_ng.ext as jp
+
+from yaml_test_core.core.context import TestContext
+from yaml_test_core.core.model import ExpectConfig, DataAssert, BaseResponse
+from yaml_test_core.core.expression.engine import ExpressionEngine
+from .assertor import SoftAssertor
+
+
+class AssertParser:
+    def __init__(
+            self,
+            soft_assertor: SoftAssertor,
+            engine: ExpressionEngine,
+            context: TestContext
+    ):
+        self.soft: SoftAssertor = soft_assertor
+        self.engine: ExpressionEngine = engine
+        self.context: TestContext = context
+
+    @staticmethod
+    def _get_json_value(resp_data: dict, json_path: str) -> Any:
+        """根据jsonpath获取返回值"""
+        expr = jp.parse(json_path)
+        match = expr.find(resp_data)
+        if not match:
+            return None
+        return [m.value for m in match] if len(match) > 1 else match[0].value
+
+    async def check_base_expect(self, resp: BaseResponse, expect: ExpectConfig):
+        """校验code、msg基础返回，异步"""
+        if expect.code is not None:
+            actual_code = resp.code
+            if isinstance(expect.code, int):
+                if actual_code != expect.code:
+                    self.soft.add_fail(f"状态码断言失败 | 预期：{expect.code} | 实际：{actual_code}")
+                else:
+                    self.soft.add_success(f"状态码断言通过 | 预期：{expect.code} | 实际：{actual_code}")
+            elif isinstance(expect.code, list):
+                if actual_code not in expect.code:
+                    self.soft.add_fail(f"状态码断言失败 | 预期：{expect.code} | 实际：{actual_code}")
+                else:
+                    self.soft.add_success(f"状态码断言通过 | 预期：{expect.code} | 实际：{actual_code}")
+
+        if expect.msg is not None:
+            actual_msg = resp.msg
+            if expect.msg.equals is not None:
+                if actual_msg != expect.msg.equals:
+                    self.soft.add_fail(f"msg相等断言失败 | 预期：{expect.msg.equals} | 实际：{actual_msg}")
+                else:
+                    self.soft.add_success(f"msg相等断言通过 | 预期：{expect.msg.equals} | 实际：{actual_msg}")
+            if expect.msg.contains is not None:
+                if expect.msg.contains not in actual_msg:
+                    self.soft.add_fail(f"msg包含断言失败 | 预期包含：{expect.msg.contains} | 实际：{actual_msg}")
+                else:
+                    self.soft.add_success(f"msg包含断言通过 | 预期包含：{expect.msg.contains} | 实际：{actual_msg}")
+
+    async def check_data_assert(self, resp: Optional[BaseResponse], data_assert: Optional[DataAssert] = None):
+        """执行全量深度数据断言，全部表达式渲染改为await"""
+        resp_data: Optional[dict] = None
+        if resp:
+            resp_data = resp.model_dump()
+            self.context.set("resp", resp_data)
+
+        if data_assert is None:
+            return
+
+        try:
+            if resp_data:
+                for path in data_assert.exists:
+                    val = self._get_json_value(resp_data, path)
+                    if val is None:
+                        self.soft.add_fail(f"存在性断言失败 | 路径 {path} 不存在")
+                    else:
+                        self.soft.add_success(f"存在性断言成功 | 路径 {path} 存在")
+
+                for path in data_assert.not_exists:
+                    val = self._get_json_value(resp_data, path)
+                    if val is not None:
+                        self.soft.add_fail(f"不存在断言失败 | 路径 {path} 不应存在")
+                    else:
+                        self.soft.add_success(f"不存在断言成功 | 路径 {path} 不应存在")
+
+                for path, compare in data_assert.array_length.items():
+                    arr = self._get_json_value(resp_data, path)
+                    if not isinstance(arr, list):
+                        self.soft.add_fail(f"数组长度断言失败 | {path} 不是数组")
+                    else:
+                        compare_rendered = await self.engine.render(compare)
+                        # 安全提示：eval存在字符串执行风险，仅限受控DSL内部使用
+                        expr = f"{len(arr)} {compare_rendered}"
+                        if not eval(expr):
+                            self.soft.add_fail(f"数组长度断言失败 | {path} | 长度：{len(arr)} | 预期：{compare}")
+                        else:
+                            self.soft.add_success(f"数组长度断言成功| {path} | 长度：{len(arr)} | 预期：{compare}")
+
+                type_map = {
+                    "str": str, "int": int, "array": list, "object": dict, "bool": bool
+                }
+                for path, target_type in data_assert.data_type.items():
+                    val = self._get_json_value(resp_data, path)
+                    target_cls = type_map[target_type]
+                    if not isinstance(val, target_cls):
+                        self.soft.add_fail(f"类型断言失败 | 路径：{path} | 预期：{target_cls.__name__} | 实际：{type(val).__name__}")
+                    else:
+                        self.soft.add_success(
+                            f"类型断言成功 | 路径：{path} | 预期：{target_cls.__name__} | 实际：{type(val).__name__}")
+
+                for path, match_rule in data_assert.value_match.items():
+                    if match_rule.equals is not None:
+                        expect_val = await self.engine.render(match_rule.equals)
+                        val = self._get_json_value(resp_data, path)
+                        if val != expect_val:
+                            self.soft.add_fail(f"等值断言失败 | 路径：{path} | 预期：{expect_val} | 实际：{val}")
+                        else:
+                            self.soft.add_success(f"等值断言成功 | 路径：{path} | 预期：{expect_val} | 实际：{val}")
+
+                    if match_rule.contains is not None:
+                        expect_contains = await self.engine.render(match_rule.contains)
+                        val = self._get_json_value(resp_data, path)
+                        if expect_contains not in str(val):
+                            self.soft.add_fail(f"包含断言失败 | 路径：{path} | 预期包含：{expect_contains} | 实际：{val}")
+                        else:
+                            self.soft.add_success(f"包含断言成功 | 路径：{path} | 预期包含：{expect_contains} | 实际：{val}")
+
+                    if match_rule.regex is not None:
+                        expect_regex = await self.engine.render(match_rule.regex)
+                        val = self._get_json_value(resp_data, path)
+                        if not re.match(expect_regex, str(val)):
+                            self.soft.add_fail(f"正则断言失败 | 路径：{path} | 正则：{expect_regex} | 实际：{val}")
+                        else:
+                            self.soft.add_success(f"正则断言成功 | 路径：{path} | 正则：{expect_regex} | 实际：{val}")
+
+                    if match_rule.in_ is not None:
+                        expect_in = await self.engine.render(match_rule.in_)
+                        val = self._get_json_value(resp_data, path)
+                        if val not in expect_in:
+                            self.soft.add_fail(f"枚举断言失败 | 路径:{path} | 预期在：{expect_in} | 实际：{val}")
+                        else:
+                            self.soft.add_success(f"枚举断言成功 | 路径：{path} | 预期在：{expect_in} | 实际：{val}")
+
+                for path in data_assert.is_null:
+                    val = self._get_json_value(resp_data, path)
+                    if val is None:
+                        self.soft.add_success(f"空值断言成功｜路径 {path} 值为null")
+                    else:
+                        self.soft.add_fail(f"空值断言失败｜路径 {path}｜预期null | 实际：{val}")
+
+                for path in data_assert.not_null:
+                    val = self._get_json_value(resp_data, path)
+                    if val is not None:
+                        self.soft.add_success(f"非空值断言成功｜路径 {path}｜预期：不为null | 实际：{val}")
+                    else:
+                        self.soft.add_fail(f"非空值断言失败｜路径 {path}｜预期：不为null | 实际：{val}")
+
+                for path in data_assert.is_empty:
+                    val = self._get_json_value(resp_data, path)
+                    empty_flag = val in ("", [], {})
+                    if empty_flag:
+                        self.soft.add_success(f"空集合断言成功｜路径 {path}｜值为空")
+                    else:
+                        self.soft.add_fail(f"空集合断言失败｜路径 {path}｜预期为空，实际:{val}")
+
+                for path in data_assert.not_empty:
+                    val = self._get_json_value(resp_data, path)
+                    empty_flag = val in ("", [], {})
+                    if not empty_flag:
+                        self.soft.add_success(f"非空集合断言成功｜路径 {path}｜不为空，实际:{val}")
+                    else:
+                        self.soft.add_fail(f"非空集合断言失败｜路径 {path}｜预期非空，实际为空:{val}")
+
+            for expr_template in data_assert.expr:
+                try:
+                    result = await self.engine.render(expr_template)
+
+                    if isinstance(result, list):
+                        if len(result) > 0:
+                            for msg in result:
+                                self.soft.add_fail(f"表达式断言失败 | {expr_template} | {msg}")
+                        else:
+                            self.soft.add_success(f"表达式断言通过 | {expr_template}")
+                        continue
+
+                    if not result:
+                        self.soft.add_fail(f"表达式断言异常 | {expr_template}")
+
+                except Exception:
+                    self.soft.add_fail(f"表达式执行异常 | {expr_template}")
+                    raise
+        finally:
+            self.context.pop("resp", None)

yaml_test_core-1.0.0/src/yaml_test_core/core/assertion/assertor.py

@@ -0,0 +1,123 @@
+from typing import Any, TypeVar
+from httpx import Response
+from pydantic import BaseModel, ValidationError
+
+from ..exceptions import AssertFailedError
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class Assertor:
+    """统一硬断言引擎"""
+
+    @staticmethod
+    def assert_status_code(response: Response, expected: int = 200) -> None:
+        """校验HTTP状态码"""
+        actual = response.status_code
+        if actual != expected:
+            raise AssertFailedError(
+                f"HTTP状态码校验失败\n预期: {expected}\n实际: {actual}\n响应内容: {response.text}"
+            )
+
+    @staticmethod
+    def assert_schema(response: Response, model: type[T]) -> T:
+        """校验响应JSON结构符合Pydantic模型，并返回模型实例"""
+        try:
+            return model(**response.json())
+        except ValidationError as e:
+            raise AssertFailedError(f"响应Schema校验失败\n错误详情: {str(e)}")
+        except Exception as e:
+            raise AssertFailedError(
+                f"响应解析失败: {str(e)}\n响应内容: {response.text}"
+            )
+
+    @staticmethod
+    def assert_equal(actual: Any, expected: Any, msg: str = "") -> None:
+        """通用相等断言"""
+        if actual != expected:
+            raise AssertFailedError(f"{msg}校验失败\n预期: {expected}\n实际: {actual}")
+
+    @staticmethod
+    def assert_not_equal(actual: Any, expected: Any, msg: str = "") -> None:
+        """通用不等断言"""
+        if actual == expected:
+            raise AssertFailedError(
+                f"{msg} 校验失败\n预期不等于: {expected}\n实际: {actual}"
+            )
+
+    @staticmethod
+    def assert_contains(
+            container: str | list | dict, target: Any, msg: str = ""
+    ) -> None:
+        """包含断言"""
+        if target not in container:
+            raise AssertFailedError(
+                f"{msg} 包含校验失败\n目标: {target}\n容器: {container}"
+            )
+
+    @staticmethod
+    def assert_true(condition: bool, msg: str = "") -> None:
+        """真值断言"""
+        if not condition:
+            raise AssertFailedError(f"{msg} 真值校验失败，条件为False")
+
+
+class SoftAssertor:
+    def __init__(self, record_success: bool = False):
+        """
+        :param record_success: 是否记录成功断言消息，由业务层传入，替代全局settings
+        """
+        self.fail_list: list[str] = []
+        self.success_list: list[str] = []
+        self.record_success = record_success
+
+    def add_fail(self, msg: str) -> None:
+        self.fail_list.append(msg)
+
+    def add_success(self, msg: str) -> None:
+        if self.record_success:
+            self.success_list.append(msg)
+
+    def clear_success(self) -> None:
+        self.success_list.clear()
+
+    def clear_fail(self) -> None:
+        self.fail_list.clear()
+
+    def clear_all(self) -> None:
+        self.clear_success()
+        self.clear_fail()
+
+    def assert_all(self) -> str | None:
+        """返回失败汇总文本，不主动抛异常；返回None代表无失败"""
+        if self.fail_list:
+            fail_msg = "\n".join([f"- {item}" for item in self.fail_list])
+            return f"存在{len(self.fail_list)}处断言失败：\n{fail_msg}"
+        return None
+
+    def get_all_fail_msg(self) -> str | None:
+        """仅返回失败文本，不主动抛错"""
+        if not self.fail_list:
+            return None
+        lines = [f"{idx + 1}. {item}" for idx, item in enumerate(self.fail_list)]
+        return "\n".join(lines)
+
+    def get_msg_list(self, msg_type: int) -> list[str]:
+        """
+        获取原始消息列表，优先推荐使用；
+        :param msg_type: 1‑success  2‑fail
+        """
+        if msg_type == 1:
+            return self.success_list.copy()
+        return self.fail_list.copy()
+
+    def get_all_msg(self, msg_type: int) -> str | None:
+        """
+        兼容旧接口：返回拼接后的字符串
+        :param msg_type: 类型 1‑success 2‑fail
+        """
+        lst = self.get_msg_list(msg_type)
+        if not lst:
+            return None
+        lines = [f"{idx + 1}. {item}" for idx, item in enumerate(lst)]
+        return "\n".join(lines)