df-test-framework 4.7.0__tar.gz → 4.7.1__tar.gz

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/CHANGELOG.md

@@ -5,6 +5,12 @@
 格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/),
 版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [4.7.1] - 2026-05-22
+
+### 🐛 修复
+
+- **Allure 报告重复记录**（`testing/fixtures/allure.py`）：`_auto_allure_observer` autouse fixture 在每次测试结束后未取消 EventBus 订阅，导致 handler 随测试数量线性累积，后续测试的每个 HTTP/DB 事件被 N 个遗留 observer 重复写入报告。现改为在 `finally` 块中逐一 unsubscribe，彻底消除重复。
+
 ## [4.7.0] - 2026-05-19
 
 ### ✨ 新增

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: df-test-framework
-Version: 4.7.0
+Version: 4.7.1
 Summary: 基于交互模式的现代化测试自动化框架，支持多种测试场景
 Project-URL: Homepage, https://github.com/yourorg/df-test-framework
 Project-URL: Repository, https://github.com/yourorg/df-test-framework

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/README.md

@@ -1,7 +1,7 @@
 # DF Test Framework
 
-> **版本**: v4.0.0
-> **更新时间**: 2026-01-16
+> **版本**: v4.7.0
+> **更新时间**: 2026-05-19
 > 简单、强大、可扩展的现代化 Python 测试自动化框架
 
 [![PyPI version](https://img.shields.io/pypi/v/df-test-framework.svg)](https://pypi.org/project/df-test-framework/)
@@ -14,6 +14,19 @@
 
 ### 当前版本亮点 ⚡🔭📊
 
+**🆕 v4.7.0 Bootstrap 多数据库 + 平台元数据**：
+- ✨ **`register_async_database(name, url)`** - 按名称注册多个异步连接池，多数据库场景（OMS/BPM 等）
+- ✨ **`get_async_database(name)`** - 每次返回绑定当前 RuntimeContext 的视图，事件携带 scope/metadata
+- ✨ **`RuntimeContext.metadata`** - 跨插件/跨进程平台上下文（tenant_id、execution_id 等）
+- ✨ **`with_metadata(**kwargs)`** - 不可变合并，与 `with_scope()` 自动联动传播
+
+**🆕 v4.6.x 测试数据管线（标准能力完整版）**：
+- ✨ **`case_dataset()` + `CaseContext[T]`** - YAML → pytest 参数化全链路，支持泛型领域模型
+- ✨ **YAML 级 skip/xfail/seed/timeout/marks/tags** - 在数据文件中声明测试行为，无需 conftest 手写
+- ✨ **自动 Allure**：pytest 插件 setup 阶段自动写标题/标签/附件，测试函数零样板
+- ✨ **CLI 过滤**：`--case`/`--case-stage`/`--case-tag`/`--case-file`/`--seed` 精准复现
+- ✨ **`DataAssetResolver`**：文件资产路径安全（禁绝对路径 + `../` 逃逸）
+
 **🚀 v4.0.0 全面异步化 - 性能飞跃**：
 - ✨ **AsyncHttpClient** - 异步 HTTP 客户端，并发性能提升 **10-30 倍**
 - ✨ **AsyncDatabase** - 异步数据库客户端，基于 SQLAlchemy 2.0 AsyncEngine

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/docs/guides/bootstrap_guide.md

@@ -1,7 +1,7 @@
 # Bootstrap 引导系统指南
 
-> **最后更新**: 2026-01-17
-> **适用版本**: v3.16.0+（Bootstrap 架构），v4.0.0+（异步支持）
+> **最后更新**: 2026-05-19
+> **适用版本**: v3.16.0+（Bootstrap 架构），v4.0.0+（异步支持），v4.7.0+（多数据库 + 平台元数据）
 
 ## 概述
 
@@ -396,6 +396,66 @@ finally:
 
 ---
 
+---
+
+## v4.7.0 扩展：多数据库 + 平台元数据
+
+### 命名 AsyncDatabase 注册（多数据库场景）
+
+```python
+# conftest.py — session 级一次性注册
+@pytest.fixture(scope="session", autouse=True)
+def register_named_databases(runtime):
+    settings = runtime.settings
+    runtime.register_async_database("oms", settings.oms_db_url)
+    runtime.register_async_database("bpm", settings.bpm_db_url)
+
+# 测试侧 — 按名称获取，每次绑定调用时的 RuntimeContext
+async def test_order_sync(runtime):
+    oms_db = runtime.get_async_database("oms")   # 连接池复用，runtime 视图是当前 context
+    bpm_db = runtime.get_async_database("bpm")
+
+    order = await oms_db.query_one("SELECT * FROM orders WHERE id = :id", {"id": 1})
+    task  = await bpm_db.query_one("SELECT * FROM tasks WHERE order_id = :id", {"id": 1})
+    assert task["status"] == "approved"
+```
+
+**核心设计**：
+- `register_async_database(name, url)` 用 `SingletonProvider` 延迟创建引擎（首次 `get_async_database` 时才建连接）
+- `get_async_database(name)` 每次返回 `db.with_runtime(self)` 视图：engine/session_factory 共享，`_runtime` 绑定当前 RuntimeContext
+- 事件（`DatabaseQueryStartEvent` 等）携带调用时的 scope 和 metadata，不会丢失测试上下文
+
+### RuntimeContext.metadata — 平台业务上下文
+
+```python
+# 创建携带租户/执行 ID 的运行时
+exec_runtime = (
+    runtime
+    .with_scope(request.node.nodeid)
+    .with_metadata(tenant_id="t-123", execution_id="exec-456")
+)
+
+# 插件或 DB 事件处理侧读取
+tenant_id = runtime.metadata.get("tenant_id")
+```
+
+`with_scope()` / `with_overrides()` 自动传播 metadata，不需要重复传入。
+
+### RuntimeBuilder 初始化时注入 metadata
+
+```python
+runtime = (
+    RuntimeBuilder()
+    .with_settings(settings)
+    .with_logger(logger)
+    .with_event_bus(event_bus)
+    .with_metadata({"env": "staging", "suite": "regression"})
+    .build()
+)
+```
+
+---
+
 ## 相关文档
 
 - [配置系统指南](config_guide.md) - FrameworkSettings 详细说明
@@ -406,4 +466,4 @@ finally:
 
 ---
 
-**完成时间**: 2026-01-17
+**完成时间**: 2026-01-17 | **最后更新**: 2026-05-19（v4.7.0）

df_test_framework-4.7.1/docs/releases/v4.7.1.md

@@ -0,0 +1,38 @@
+# v4.7.1 发布说明
+
+**发布日期**: 2026-05-22
+**类型**: Bug Fix
+
+---
+
+## 问题描述
+
+Allure 报告中 HTTP 请求和数据库查询内容出现重复记录。测试越多，同一个事件在报告里出现的次数就越多（第 N 个测试的事件会出现 N 次）。
+
+## 根本原因
+
+`testing/fixtures/allure.py` 中的 `_auto_allure_observer` autouse fixture 在每次测试结束后没有取消 EventBus 订阅。
+
+```
+测试 1 结束：EventBus 仍保留 observer_1 的 22 个 handler
+测试 2 结束：EventBus 保留 observer_1 + observer_2 共 44 个 handler
+测试 N 运行：每个 HTTP/DB 事件触发 N 个 handler，写入 N 条 allure step
+```
+
+v3.46.1 重构时注释写"不需要取消订阅，因为使用全局 EventBus + scope 过滤"，但订阅时 `scope=None` 表示接收所有事件，不做过滤——旧 observer 的 handler 在整个 session 中持续活跃，向当前测试的 allure 上下文写入重复数据。
+
+## 修复内容
+
+`testing/fixtures/allure.py` - `_auto_allure_observer`：
+
+- 将 22 个订阅改为列表管理（`subscriptions`）
+- 在 `finally` 块中逐一调用 `unsubscribe`，确保测试结束后 handler 从全局 EventBus 移除
+- 嵌套 `try/finally` 保证即使 unsubscribe 抛异常，`observer.cleanup()` 和 `set_current_observer(None)` 仍然执行
+
+## 升级方式
+
+无 API 变更，直接升级即可：
+
+```bash
+uv add df-test-framework==4.7.1
+```

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "df-test-framework"
-version = "4.7.0"
+version = "4.7.1"
 description = "基于交互模式的现代化测试自动化框架，支持多种测试场景"
 authors = [{name = "DF QA Team", email = "qa@example.com"}]
 readme = "README_PYPI.md"

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/src/df_test_framework/__init__.py

@@ -197,7 +197,7 @@ v3.18.1 特性:
 - 🔄 Unit of Work 模式支持（v3.7）
 """
 
-__version__ = "4.7.0"
+__version__ = "4.7.1"
 __author__ = "DF QA Team"
 
 # ==============================================================================

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/src/df_test_framework/cli/templates/project/pyproject_toml.py

@@ -92,9 +92,9 @@ timeout_method = "thread"
 # v4.0.0: pytest-asyncio 配置（异步测试支持）
 # auto 模式：自动识别异步测试，无需 @pytest.mark.asyncio 装饰器
 asyncio_mode = "auto"
-# v4.1.0: 不再需要 asyncio_default_fixture_loop_scope = "session"
-# 框架的 async session fixtures 已使用 @pytest_asyncio.fixture(loop_scope="session") 精确控制
-# 这样 sync Playwright 等 session fixtures 不受 asyncio event loop 干扰
+# v4.7.0: 显式设置为 function（pytest-asyncio 的未来默认值），消除 PytestDeprecationWarning
+# async session fixtures 已使用 @pytest_asyncio.fixture(loop_scope="session") 精确控制，不受影响
+asyncio_default_fixture_loop_scope = "function"
 
 # Live logging: 实时显示日志（运行时）
 # 本地调试时使用: pytest --log-cli-level=DEBUG -v -s

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/src/df_test_framework/testing/fixtures/allure.py

@@ -197,99 +197,54 @@ def _auto_allure_observer(request) -> Generator[AllureObserver | None, None, Non
     # Allure 作为全局观察者，使用 scope=None 订阅所有事件
     test_event_bus = get_global_event_bus()
 
-    # v3.18.0: 订阅所有能力层事件（统一 EventBus 驱动）
-    # v3.46.1: 使用 scope=None 全局订阅，接收所有事件
-    # Allure 作为全局观察者，记录所有测试的事件
-    # HTTP 事件
-    test_event_bus.subscribe(
-        HttpRequestStartEvent, observer.handle_http_request_start_event, scope=None
-    )
-    test_event_bus.subscribe(
-        HttpRequestEndEvent, observer.handle_http_request_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        HttpRequestErrorEvent, observer.handle_http_request_error_event, scope=None
-    )
-    test_event_bus.subscribe(
-        MiddlewareExecuteEvent, observer.handle_middleware_execute_event, scope=None
-    )
-
-    # Database 事件
-    test_event_bus.subscribe(
-        DatabaseQueryStartEvent, observer.handle_database_query_start_event, scope=None
-    )
-    test_event_bus.subscribe(
-        DatabaseQueryEndEvent, observer.handle_database_query_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        DatabaseQueryErrorEvent, observer.handle_database_query_error_event, scope=None
-    )
-
-    # Cache 事件 (Redis)
-    test_event_bus.subscribe(
-        CacheOperationStartEvent, observer.handle_cache_operation_start_event, scope=None
-    )
-    test_event_bus.subscribe(
-        CacheOperationEndEvent, observer.handle_cache_operation_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        CacheOperationErrorEvent, observer.handle_cache_operation_error_event, scope=None
-    )
-
-    # MQ 事件 (v3.34.1 重构为 End/Error 模式)
-    test_event_bus.subscribe(
-        MessagePublishEndEvent, observer.handle_message_publish_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        MessagePublishErrorEvent, observer.handle_message_publish_error_event, scope=None
-    )
-    test_event_bus.subscribe(
-        MessageConsumeEndEvent, observer.handle_message_consume_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        MessageConsumeErrorEvent, observer.handle_message_consume_error_event, scope=None
-    )
-
-    # Storage 事件
-    test_event_bus.subscribe(
-        StorageOperationStartEvent, observer.handle_storage_operation_start_event, scope=None
-    )
-    test_event_bus.subscribe(
-        StorageOperationEndEvent, observer.handle_storage_operation_end_event, scope=None
-    )
-    test_event_bus.subscribe(
-        StorageOperationErrorEvent, observer.handle_storage_operation_error_event, scope=None
-    )
-
-    # Transaction 事件 (v3.18.0)
-    test_event_bus.subscribe(
-        TransactionCommitEvent, observer.handle_transaction_commit_event, scope=None
-    )
-    test_event_bus.subscribe(
-        TransactionRollbackEvent, observer.handle_transaction_rollback_event, scope=None
-    )
-
-    # Web UI 事件 (v3.44.0)
-    test_event_bus.subscribe(
-        UIActionEvent, observer.handle_ui_action_event, scope=None
-    )  # v3.46.0: AppActions
-    test_event_bus.subscribe(
-        WebBrowserEvent, observer.handle_web_browser_event, scope=None
-    )  # Playwright 原生
-    test_event_bus.subscribe(UIErrorEvent, observer.handle_ui_error_event, scope=None)
+    # 用列表管理所有订阅，便于测试结束后统一取消订阅
+    subscriptions = [
+        # HTTP 事件
+        (HttpRequestStartEvent, observer.handle_http_request_start_event),
+        (HttpRequestEndEvent, observer.handle_http_request_end_event),
+        (HttpRequestErrorEvent, observer.handle_http_request_error_event),
+        (MiddlewareExecuteEvent, observer.handle_middleware_execute_event),
+        # Database 事件
+        (DatabaseQueryStartEvent, observer.handle_database_query_start_event),
+        (DatabaseQueryEndEvent, observer.handle_database_query_end_event),
+        (DatabaseQueryErrorEvent, observer.handle_database_query_error_event),
+        # Cache 事件 (Redis)
+        (CacheOperationStartEvent, observer.handle_cache_operation_start_event),
+        (CacheOperationEndEvent, observer.handle_cache_operation_end_event),
+        (CacheOperationErrorEvent, observer.handle_cache_operation_error_event),
+        # MQ 事件 (v3.34.1 重构为 End/Error 模式)
+        (MessagePublishEndEvent, observer.handle_message_publish_end_event),
+        (MessagePublishErrorEvent, observer.handle_message_publish_error_event),
+        (MessageConsumeEndEvent, observer.handle_message_consume_end_event),
+        (MessageConsumeErrorEvent, observer.handle_message_consume_error_event),
+        # Storage 事件
+        (StorageOperationStartEvent, observer.handle_storage_operation_start_event),
+        (StorageOperationEndEvent, observer.handle_storage_operation_end_event),
+        (StorageOperationErrorEvent, observer.handle_storage_operation_error_event),
+        # Transaction 事件 (v3.18.0)
+        (TransactionCommitEvent, observer.handle_transaction_commit_event),
+        (TransactionRollbackEvent, observer.handle_transaction_rollback_event),
+        # Web UI 事件 (v3.44.0)
+        (UIActionEvent, observer.handle_ui_action_event),
+        (WebBrowserEvent, observer.handle_web_browser_event),
+        (UIErrorEvent, observer.handle_ui_error_event),
+    ]
+
+    for event_type, handler in subscriptions:
+        test_event_bus.subscribe(event_type, handler, scope=None)
 
     try:
-        # yield让测试执行
-        # 注意: 不需要用 with allure.step()，因为HTTP请求会创建自己的step
         yield observer
     finally:
-        # 测试结束，清理observer
-        # cleanup() 会关闭所有未正常结束的 step 上下文（异常安全）
-        observer.cleanup()
-        set_current_observer(None)
-
-        # v3.46.1: 不需要取消订阅，因为使用全局 EventBus + scope 过滤
-        # 订阅者在整个测试会话中保持活跃，每个测试使用不同的 observer 实例
+        try:
+            # 取消订阅所有 handler，防止旧 observer 在后续测试中继续触发导致重复记录
+            for event_type, handler in subscriptions:
+                test_event_bus.unsubscribe(event_type, handler)
+        finally:
+            try:
+                observer.cleanup()
+            finally:
+                set_current_observer(None)
 
 
 __all__ = ["_auto_allure_observer"]

df_test_framework-4.7.1/tests/testing/fixtures/test_allure_fixture.py

@@ -0,0 +1,155 @@
+"""Allure fixture 回归测试。"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from df_test_framework.core.events import HttpRequestStartEvent
+from df_test_framework.infrastructure.events import EventBus, set_global_event_bus
+from df_test_framework.testing.fixtures import allure as allure_fixture
+
+
+class FakeAllureObserver:
+    """用于验证 fixture 订阅生命周期的 AllureObserver 替身。"""
+
+    instances: list[FakeAllureObserver] = []
+
+    def __init__(self, test_name: str):
+        self.test_name = test_name
+        self.http_start_events: list[HttpRequestStartEvent] = []
+        self.cleaned = False
+        FakeAllureObserver.instances.append(self)
+
+    async def handle_http_request_start_event(self, event: HttpRequestStartEvent) -> None:
+        """记录 HTTP 请求开始事件。"""
+        self.http_start_events.append(event)
+
+    async def handle_http_request_end_event(self, event) -> None:
+        """忽略 HTTP 请求结束事件。"""
+
+    async def handle_http_request_error_event(self, event) -> None:
+        """忽略 HTTP 请求错误事件。"""
+
+    async def handle_middleware_execute_event(self, event) -> None:
+        """忽略中间件事件。"""
+
+    def handle_database_query_start_event(self, event) -> None:
+        """忽略数据库查询开始事件。"""
+
+    def handle_database_query_end_event(self, event) -> None:
+        """忽略数据库查询结束事件。"""
+
+    def handle_database_query_error_event(self, event) -> None:
+        """忽略数据库查询错误事件。"""
+
+    async def handle_cache_operation_start_event(self, event) -> None:
+        """忽略缓存操作开始事件。"""
+
+    async def handle_cache_operation_end_event(self, event) -> None:
+        """忽略缓存操作结束事件。"""
+
+    async def handle_cache_operation_error_event(self, event) -> None:
+        """忽略缓存操作错误事件。"""
+
+    async def handle_message_publish_end_event(self, event) -> None:
+        """忽略消息发布成功事件。"""
+
+    async def handle_message_publish_error_event(self, event) -> None:
+        """忽略消息发布错误事件。"""
+
+    async def handle_message_consume_end_event(self, event) -> None:
+        """忽略消息消费成功事件。"""
+
+    async def handle_message_consume_error_event(self, event) -> None:
+        """忽略消息消费错误事件。"""
+
+    async def handle_storage_operation_start_event(self, event) -> None:
+        """忽略存储操作开始事件。"""
+
+    async def handle_storage_operation_end_event(self, event) -> None:
+        """忽略存储操作结束事件。"""
+
+    async def handle_storage_operation_error_event(self, event) -> None:
+        """忽略存储操作错误事件。"""
+
+    def handle_transaction_commit_event(self, event) -> None:
+        """忽略事务提交事件。"""
+
+    def handle_transaction_rollback_event(self, event) -> None:
+        """忽略事务回滚事件。"""
+
+    async def handle_ui_action_event(self, event) -> None:
+        """忽略 UI 操作事件。"""
+
+    async def handle_web_browser_event(self, event) -> None:
+        """忽略浏览器事件。"""
+
+    async def handle_ui_error_event(self, event) -> None:
+        """忽略 UI 错误事件。"""
+
+    def cleanup(self) -> None:
+        """标记清理已执行。"""
+        self.cleaned = True
+
+
+@pytest.fixture
+def patched_allure_fixture(monkeypatch: pytest.MonkeyPatch):
+    """替换 Allure 依赖，避免测试依赖真实 allure 运行环境。"""
+    FakeAllureObserver.instances.clear()
+    bus = EventBus()
+    set_global_event_bus(bus)
+
+    monkeypatch.setattr(allure_fixture, "ALLURE_AVAILABLE", True)
+    monkeypatch.setattr(allure_fixture, "allure", object())
+    monkeypatch.setattr(allure_fixture, "AllureObserver", FakeAllureObserver)
+
+    current_observers = []
+    monkeypatch.setattr(
+        allure_fixture,
+        "set_current_observer",
+        lambda observer: current_observers.append(observer),
+    )
+
+    return bus
+
+
+def _run_auto_allure_fixture(test_name: str):
+    request = SimpleNamespace(node=SimpleNamespace(name=test_name))
+    generator = allure_fixture._auto_allure_observer.__wrapped__(request)
+    observer = next(generator)
+    return generator, observer
+
+
+@pytest.mark.asyncio
+async def test_auto_allure_observer_unsubscribes_handlers_after_test(
+    patched_allure_fixture: EventBus,
+) -> None:
+    """测试结束后必须退订 observer，避免后续测试重复记录 Allure 附件。"""
+    bus = patched_allure_fixture
+
+    first_generator, first_observer = _run_auto_allure_fixture("test_first")
+    assert bus.handler_count() == 22
+
+    with pytest.raises(StopIteration):
+        next(first_generator)
+
+    assert bus.handler_count() == 0
+    assert first_observer.cleaned is True
+
+    await bus.publish(HttpRequestStartEvent(method="GET", url="/after-first"))
+    assert first_observer.http_start_events == []
+
+    second_generator, second_observer = _run_auto_allure_fixture("test_second")
+    assert bus.handler_count() == 22
+
+    await bus.publish(HttpRequestStartEvent(method="GET", url="/second"))
+    assert len(first_observer.http_start_events) == 0
+    assert len(second_observer.http_start_events) == 1
+
+    with pytest.raises(StopIteration):
+        next(second_generator)
+
+    assert bus.handler_count() == 0
+    assert second_observer.cleaned is True

{df_test_framework-4.7.0 → df_test_framework-4.7.1}/uv.lock

@@ -590,7 +590,7 @@ wheels = [
 
 [[package]]
 name = "df-test-framework"
-version = "4.7.0"
+version = "4.7.1"
 source = { editable = "." }
 dependencies = [
     { name = "allure-pytest" },