pytrunner 1.0.0__py3-none-any.whl

pytrunner/__init__.py

@@ -0,0 +1,21 @@
+"""pytrunner —— Python 项目全覆盖测试框架（命名空间根包）。"""
+
+import sys
+
+# 兼容仓库「脚本模式」（根目录在 sys.path 上时 `from core.x` / `from tests.x` 等可用）。
+# 打包为命名空间包后顶层不再有这些子包，这里把别名指回本包子模块，
+# 使既有绝对导入在包模式下仍能解析。若已有同名顶层包则不动（setdefault）。
+for _alias, _sub in (
+    ("core", "pytrunner.core"),
+    ("console", "pytrunner.console"),
+    ("gui", "pytrunner.gui"),
+    ("tests", "pytrunner.tests"),
+    ("probes", "pytrunner.probes"),
+    ("scanners", "pytrunner.scanners"),
+):
+    try:
+        __import__(_sub)
+        sys.modules.setdefault(_alias, sys.modules[_sub])
+    except ImportError:
+        pass
+del _alias, _sub

pytrunner/console/__init__.py

@@ -0,0 +1 @@
+# console — 控制台模式界面

pytrunner/console/console_ui.py

@@ -0,0 +1,67 @@
+"""
+控制台测试界面 — 纯终端交互模式。
+
+适用场景：
+    - CI/CD 流水线
+    - 无 GUI 环境
+    - 脚本自动化
+"""
+
+import sys
+import os
+from typing import List, Callable
+
+# 强制 stdout 使用 UTF-8，避免 emoji 等字符在 GBK 下报错
+sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
+from core.log_manager import LogManager
+from core.test_runner import TestRunner
+from core.error_types import ErrorCode
+
+
+class ConsoleUI:
+    """控制台测试界面"""
+
+    def __init__(self, log_manager: LogManager):
+        self.log = log_manager
+        self.runner = TestRunner(log_manager)
+
+    def print_banner(self):
+        """打印启动横幅"""
+        banner = r"""
+   ╔══════════════════════════════════════════════════╗
+   ║            🧪  测试框架  v1.0                     ║
+   ║            Console Mode                         ║
+   ╚══════════════════════════════════════════════════╝
+        """
+        self.log.print_colored(banner, bold=True)
+
+    def run(self, test_fns: List[Callable], timeout: float = 30.0):
+        """执行测试套件"""
+        self.print_banner()
+        self.runner.timeout = timeout
+
+        try:
+            results = self.runner.run_tests(test_fns)
+            self.log.print_summary()
+
+            # 返回退出码
+            has_failure = any(
+                r.error_code.category.value in ("失败", "错误")
+                for r in results
+            )
+            if has_failure:
+                self.log.print_colored("⚠️  有测试未通过！", bold=True)
+                return 1
+            else:
+                self.log.print_colored("✅ 全部测试通过！", bold=True)
+                return 0
+
+        except KeyboardInterrupt:
+            self.log.print_colored("\n⚠️  测试被用户中断", bold=True)
+            return 2
+        except Exception as e:
+            self.log.print_colored(f"\n💥 测试框架崩溃: {e}", bold=True)
+            import traceback
+            traceback.print_exc()
+            return 3

pytrunner/core/__init__.py

@@ -0,0 +1 @@
+# core — 测试框架核心引擎

pytrunner/core/error_types.py

@@ -0,0 +1,149 @@
+"""
+错误类型定义 — 明确分类测试中可能出现的所有错误。
+
+设计原则：
+    每种错误类型都有唯一的 name/code/emoji，方便日志筛选和 GUI 渲染。
+"""
+
+from enum import Enum
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+class ErrorCategory(Enum):
+    """错误大类"""
+    PASS = "通过"
+    FAIL = "失败"
+    ERROR = "错误"
+    SKIP = "跳过"
+
+
+class ErrorCode(Enum):
+    """错误细类 — 每种错误有唯一标识码"""
+
+    # ── 通过 ──
+    TEST_PASS = ("PASS-000", "测试通过", ErrorCategory.PASS, "✅")
+
+    # ── 断言失败 ──
+    ASSERT_EQUAL = ("FAIL-001", "断言相等失败：期望值与实际值不符", ErrorCategory.FAIL, "❌")
+    ASSERT_TRUE = ("FAIL-002", "断言为真失败：表达式求值为 False", ErrorCategory.FAIL, "❌")
+    ASSERT_FALSE = ("FAIL-003", "断言为假失败：表达式求值为 True", ErrorCategory.FAIL, "❌")
+    ASSERT_IN = ("FAIL-004", "断言包含失败：值不在集合中", ErrorCategory.FAIL, "❌")
+    ASSERT_RAISES = ("FAIL-005", "断言异常失败：未抛出预期异常", ErrorCategory.FAIL, "❌")
+    UNEXPECTED_RESULT = ("FAIL-006", "意外结果：返回值与预期不符", ErrorCategory.FAIL, "❌")
+
+    # ── 运行时错误 ──
+    RUNTIME_ERROR = ("ERR-001", "运行时错误", ErrorCategory.ERROR, "💥")
+    ATTRIBUTE_ERROR = ("ERR-002", "属性错误：对象没有该属性或方法", ErrorCategory.ERROR, "💥")
+    TYPE_ERROR = ("ERR-003", "类型错误：操作数类型不匹配", ErrorCategory.ERROR, "💥")
+    VALUE_ERROR = ("ERR-004", "值错误：参数值不合法", ErrorCategory.ERROR, "💥")
+    KEY_ERROR = ("ERR-005", "键错误：字典中不存在该键", ErrorCategory.ERROR, "💥")
+    INDEX_ERROR = ("ERR-006", "索引错误：序列索引越界", ErrorCategory.ERROR, "💥")
+    ZERO_DIVISION = ("ERR-007", "零除错误：除数为零", ErrorCategory.ERROR, "💥")
+    NAME_ERROR = ("ERR-008", "名称错误：变量未定义", ErrorCategory.ERROR, "💥")
+    OS_ERROR = ("ERR-009", "系统错误：操作系统相关异常", ErrorCategory.ERROR, "💥")
+    IO_ERROR = ("ERR-010", "IO 错误：文件读写失败", ErrorCategory.ERROR, "💥")
+    RECURSION_ERROR = ("ERR-011", "递归错误：递归深度超限", ErrorCategory.ERROR, "💥")
+    MEMORY_ERROR = ("ERR-012", "内存错误：内存不足", ErrorCategory.ERROR, "💥")
+
+    # ── 语法/导入错误 ──
+    SYNTAX_ERROR = ("ERR-101", "语法错误：代码无法解析", ErrorCategory.ERROR, "📝")
+    IMPORT_ERROR = ("ERR-102", "导入错误：模块不存在或无法加载", ErrorCategory.ERROR, "📝")
+    INDENTATION_ERROR = ("ERR-103", "缩进错误：代码缩进不正确", ErrorCategory.ERROR, "📝")
+    MODULE_NOT_FOUND = ("ERR-104", "模块未找到：依赖缺失", ErrorCategory.ERROR, "📝")
+
+    # ── 超时错误 ──
+    TIMEOUT_ERROR = ("ERR-201", "超时错误：执行超过时间限制", ErrorCategory.ERROR, "⏱️")
+
+    # ── 测试框架错误 ──
+    SETUP_ERROR = ("ERR-301", "准备阶段错误：setUp 方法异常", ErrorCategory.ERROR, "🔧")
+    TEARDOWN_ERROR = ("ERR-302", "清理阶段错误：tearDown 方法异常", ErrorCategory.ERROR, "🔧")
+    FIXTURE_ERROR = ("ERR-303", "夹具错误：测试数据准备失败", ErrorCategory.ERROR, "🔧")
+
+    # ── 跳过 ──
+    TEST_SKIP = ("SKIP-000", "测试跳过", ErrorCategory.SKIP, "⏭️")
+    SKIP_CONDITION = ("SKIP-001", "条件跳过：前置条件不满足", ErrorCategory.SKIP, "⏭️")
+    SKIP_PLATFORM = ("SKIP-002", "平台跳过：当前平台不支持", ErrorCategory.SKIP, "⏭️")
+
+    # ── 测试探针 ──（快速冒烟检测）
+    PROBE_PASS = ("PROBE-PASS", "探针通过：检测点正常", ErrorCategory.PASS, "📍")
+    PROBE_FAIL = ("PROBE-FAIL", "探针失败：检测点异常", ErrorCategory.FAIL, "📍")
+    PROBE_SKIP = ("PROBE-SKIP", "探针跳过：条件不满足", ErrorCategory.SKIP, "📍")
+
+    # ── 未知 ──
+    UNKNOWN_ERROR = ("ERR-999", "未知错误：无法归类的异常", ErrorCategory.ERROR, "❓")
+
+    @classmethod
+    def from_exception(cls, exc: Exception) -> "ErrorCode":
+        """根据异常类型自动匹配 ErrorCode"""
+        mapping = {
+            AssertionError: cls.ASSERT_EQUAL,
+            AttributeError: cls.ATTRIBUTE_ERROR,
+            TypeError: cls.TYPE_ERROR,
+            ValueError: cls.VALUE_ERROR,
+            KeyError: cls.KEY_ERROR,
+            IndexError: cls.INDEX_ERROR,
+            ZeroDivisionError: cls.ZERO_DIVISION,
+            NameError: cls.NAME_ERROR,
+            OSError: cls.OS_ERROR,
+            IOError: cls.IO_ERROR,
+            RecursionError: cls.RECURSION_ERROR,
+            MemoryError: cls.MEMORY_ERROR,
+            SyntaxError: cls.SYNTAX_ERROR,
+            ImportError: cls.IMPORT_ERROR,
+            IndentationError: cls.INDENTATION_ERROR,
+            ModuleNotFoundError: cls.MODULE_NOT_FOUND,
+            TimeoutError: cls.TIMEOUT_ERROR,
+        }
+        return mapping.get(type(exc), cls.UNKNOWN_ERROR)
+
+    @property
+    def code(self) -> str:
+        return self.value[0]
+
+    @property
+    def description(self) -> str:
+        return self.value[1]
+
+    @property
+    def category(self) -> ErrorCategory:
+        return self.value[2]
+
+    @property
+    def emoji(self) -> str:
+        return self.value[3]
+
+
+@dataclass
+class TestError:
+    """单条测试错误记录"""
+    error_code: ErrorCode
+    message: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    traceback: Optional[str] = None
+    test_name: str = ""
+    file_path: str = ""
+    line_number: int = 0
+
+    def brief(self) -> str:
+        """一行摘要"""
+        loc = f"{self.file_path}:{self.line_number}" if self.file_path else ""
+        return f"[{self.error_code.code}] {self.error_code.emoji} {self.message}  {loc}"
+
+    def detail(self) -> str:
+        """完整详情"""
+        lines = [
+            f"{'='*60}",
+            f"  错误码 : {self.error_code.code}",
+            f"  类型   : {self.error_code.description}",
+            f"  时间   : {self.timestamp.strftime('%Y-%m-%d %H:%M:%S')}",
+            f"  测试   : {self.test_name}",
+        ]
+        if self.file_path:
+            lines.append(f"  位置   : {self.file_path}:{self.line_number}")
+        lines.append(f"  消息   : {self.message}")
+        if self.traceback:
+            lines.append(f"  堆栈   :\n{self.traceback}")
+        lines.append(f"{'='*60}")
+        return "\n".join(lines)

pytrunner/core/log_manager.py

@@ -0,0 +1,177 @@
+"""
+日志管理器 — 统一管理控制台输出、GUI 回调和文件写入。
+
+功能：
+    - 同时输出到多个目标（控制台/GUI 回调/文件）
+    - 按错误级别自动着色
+    - 自动创建带时间戳的日志文件
+    - 线程安全
+"""
+
+import threading
+from datetime import datetime
+from typing import Optional, Callable, List
+from pathlib import Path
+
+from .error_types import ErrorCode, TestError, ErrorCategory
+
+
+class LogManager:
+    """多路日志管理器"""
+
+    # 控制台颜色（Windows 10+ 支持 ANSI）
+    COLORS = {
+        ErrorCategory.PASS: "\033[32m",
+        ErrorCategory.FAIL: "\033[31m",
+        ErrorCategory.ERROR: "\033[35m",
+        ErrorCategory.SKIP: "\033[33m",
+        "reset": "\033[0m",
+        "bold": "\033[1m",
+        "dim": "\033[2m",
+        "header": "\033[1;36m",
+    }
+
+    def __init__(self, log_dir: str = "logs", use_color: bool = True):
+        self.log_dir = Path(log_dir)
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.log_path = self.log_dir / f"test_run_{timestamp}.log"
+        self.error_path = self.log_dir / f"test_errors_{timestamp}.log"
+
+        self._lock = threading.RLock()
+        self._gui_callbacks: List[Callable[[str], None]] = []
+        self._error_callbacks: List[Callable[[TestError], None]] = []
+        self._errors: List[TestError] = []
+        self._log_entries: List[str] = []
+        self._use_color = use_color
+
+        self._write_to_file(self.log_path, f"=== 测试日志 === 开始时间: {datetime.now()}\n", mode='w')
+        self._write_to_file(self.error_path, f"=== 错误日志 === 开始时间: {datetime.now()}\n\n", mode='w')
+
+    # ── 回调注册 ──
+    def on_log(self, callback: Callable[[str], None]):
+        self._gui_callbacks.append(callback)
+
+    def on_error(self, callback: Callable[[TestError], None]):
+        self._error_callbacks.append(callback)
+
+    # ── 写入 ──
+    def _write_to_file(self, path: Path, text: str, mode: str = 'a'):
+        try:
+            with open(path, mode, encoding='utf-8') as f:
+                f.write(text)
+        except OSError:
+            pass
+
+    def _notify_gui(self, line: str):
+        for cb in self._gui_callbacks:
+            try:
+                cb(line)
+            except Exception:
+                pass
+
+    def _notify_error(self, error: TestError):
+        for cb in self._error_callbacks:
+            try:
+                cb(error)
+            except Exception:
+                pass
+
+    # ── 日志方法 ──
+    def log(self, msg: str, level: str = "INFO"):
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        line = f"[{timestamp}] [{level}] {msg}"
+        with self._lock:
+            self._log_entries.append(line)
+            self._write_to_file(self.log_path, line + "\n")
+            self._notify_gui(line)
+
+    def info(self, msg: str):
+        self.log(msg, "INFO")
+
+    def warning(self, msg: str):
+        self.log(msg, "WARN")
+
+    def debug(self, msg: str):
+        self.log(msg, "DEBUG")
+
+    def error(self, test_error: TestError):
+        """记录结构化错误"""
+        with self._lock:
+            self._errors.append(test_error)
+            self._write_to_file(self.error_path, test_error.detail() + "\n")
+            line = f"[{datetime.now().strftime('%H:%M:%S')}] [ERROR] {test_error.brief()}"
+            self._log_entries.append(line)
+            self._write_to_file(self.log_path, line + "\n")
+            self._notify_gui(line)
+            self._notify_error(test_error)
+
+    def section(self, title: str):
+        """打印分隔标题"""
+        line = f"\n{'━'*50}\n  {title}\n{'━'*50}"
+        with self._lock:
+            self._log_entries.append(line)
+            self._write_to_file(self.log_path, line + "\n")
+            self._notify_gui(line)
+
+    # ── 控制台输出 ──
+    def print_colored(self, msg: str, category: Optional[ErrorCategory] = None, bold: bool = False):
+        """带颜色的控制台输出"""
+        if self._use_color:
+            color = self.COLORS.get(category, "")
+            style = self.COLORS["bold"] if bold else ""
+            reset = self.COLORS["reset"]
+            print(f"{style}{color}{msg}{reset}", flush=True)
+        else:
+            print(msg, flush=True)
+
+    def print_result(self, error_code: ErrorCode, test_name: str, duration: float = 0):
+        """打印单条测试结果"""
+        emoji = error_code.emoji
+        duration_str = f"({duration:.3f}s)" if duration > 0 else ""
+        msg = f"  {emoji} {test_name:<40} {error_code.code:<10} {duration_str}"
+        self.print_colored(msg, category=error_code.category)
+
+    # ── 汇总报告 ──
+    def print_summary(self):
+        """控制台打印汇总报告"""
+        total = len(self._errors)
+        passed = sum(1 for e in self._errors if e.error_code.category == ErrorCategory.PASS)
+        failed = sum(1 for e in self._errors if e.error_code.category == ErrorCategory.FAIL)
+        errored = sum(1 for e in self._errors if e.error_code.category == ErrorCategory.ERROR)
+        skipped = sum(1 for e in self._errors if e.error_code.category == ErrorCategory.SKIP)
+
+        self.section("测试汇总")
+        print()
+        self.print_colored(f"  总计  : {total}  个测试", bold=True)
+        self.print_colored(f"  通过  : {passed} ✅", ErrorCategory.PASS)
+        self.print_colored(f"  失败  : {failed} ❌", ErrorCategory.FAIL)
+        self.print_colored(f"  错误  : {errored} 💥", ErrorCategory.ERROR)
+        self.print_colored(f"  跳过  : {skipped} ⏭️", ErrorCategory.SKIP)
+        print()
+        self.print_colored(f"  日志文件: {self.log_path}", bold=False)
+        self.print_colored(f"  错误文件: {self.error_path}", bold=False)
+        print()
+
+        error_list = [e for e in self._errors if e.error_code.category != ErrorCategory.PASS]
+        if error_list:
+            self.print_colored("失败/错误详情:", ErrorCategory.ERROR, bold=True)
+            for e in error_list:
+                self.print_colored(f"    {e.brief()}", e.error_code.category)
+            print()
+
+    def get_summary(self) -> dict:
+        """返回汇总数据（GUI 用）"""
+        total = len(self._errors)
+        return {
+            "total": total,
+            "passed": sum(1 for e in self._errors if e.error_code.category == ErrorCategory.PASS),
+            "failed": sum(1 for e in self._errors if e.error_code.category == ErrorCategory.FAIL),
+            "errored": sum(1 for e in self._errors if e.error_code.category == ErrorCategory.ERROR),
+            "skipped": sum(1 for e in self._errors if e.error_code.category == ErrorCategory.SKIP),
+            "log_path": str(self.log_path),
+            "error_path": str(self.error_path),
+            "errors": self._errors,
+            "entries": self._log_entries,
+        }

pytrunner/core/test_probe.py

@@ -0,0 +1,200 @@
+"""
+测试探针系统 — 通过插入轻量级探针进行冒烟测试。
+
+概念：
+    测试探针（Probe）是在关键路径上插入的轻量检测点。
+    不改变被测代码逻辑，仅在关键节点做快速验证。
+    适合 CI/CD 冒烟测试、部署后健康检查、快速回归验证。
+
+设计原则：
+    - 探针是无副作用的只读检查
+    - 批量触发，快速扫过所有探针点
+    - 失败探针记录详细上下文
+"""
+
+import time
+import traceback
+from typing import Any, Callable, Dict, List, Optional, Set
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from .error_types import ErrorCode, TestError, ErrorCategory
+from .log_manager import LogManager
+
+
+@dataclass
+class Probe:
+    """单个测试探针
+
+    Args:
+        name: 探针名称（唯一标识）
+        check: 检查函数，返回 (passed: bool, detail: str)
+        category: 探针分类（如 "启动", "数据库", "API", "UI"）
+        priority: 优先级 1-5，1 最高（数字越小越优先扫描）
+        tags: 标签集合，用于按标签筛选探针
+        timeout: 超时秒数
+    """
+    name: str
+    check: Callable[[], tuple[bool, str]]
+    category: str = "通用"
+    priority: int = 3
+    tags: Set[str] = field(default_factory=set)
+    timeout: float = 3.0
+
+    def run(self) -> TestError:
+        """执行探针检测，返回 TestError"""
+        start = time.perf_counter()
+        try:
+            passed, detail = self.check()
+        except Exception as e:
+            duration = time.perf_counter() - start
+            return TestError(
+                error_code=ErrorCode.PROBE_FAIL,
+                message=f"{type(e).__name__}: {e}",
+                test_name=f"[探针] {self.name}",
+                traceback=traceback.format_exc(),
+            )
+
+        duration = time.perf_counter() - start
+        if passed:
+            return TestError(
+                error_code=ErrorCode.PROBE_PASS,
+                message=f"✅ {detail} ({duration:.3f}s)",
+                test_name=f"[探针] {self.name}",
+            )
+        else:
+            return TestError(
+                error_code=ErrorCode.PROBE_FAIL,
+                message=f"❌ {detail} ({duration:.3f}s)",
+                test_name=f"[探针] {self.name}",
+            )
+
+
+class ProbeManager:
+    """探针管理器 — 注册、筛选、批量执行"""
+
+    def __init__(self, log_manager: LogManager):
+        self.log = log_manager
+        self._probes: List[Probe] = []
+
+    # ── 注册 ──
+    def register(self, probe: Probe):
+        """注册一个探针"""
+        self._probes.append(probe)
+
+    def register_batch(self, probes: List[Probe]):
+        """批量注册探针"""
+        self._probes.extend(probes)
+
+    @property
+    def count(self) -> int:
+        return len(self._probes)
+
+    # ── 筛选 ──
+    def filter(self, *, category: str = None, tags: Set[str] = None,
+               max_priority: int = None) -> List[Probe]:
+        """按条件筛选探针
+
+        Args:
+            category: 按分类筛选
+            tags: 按标签筛选（包含任一标签即匹配）
+            max_priority: 最大优先级（数字），只返回优先级 <= 此值的探针
+        """
+        result = self._probes
+        if category:
+            result = [p for p in result if p.category == category]
+        if tags:
+            result = [p for p in result if p.tags & tags]
+        if max_priority is not None:
+            result = [p for p in result if p.priority <= max_priority]
+        return result
+
+    def smoke_probes(self) -> List[Probe]:
+        """获取冒烟探针：仅 priority=1 的关键路径探针"""
+        return self.filter(max_priority=1)
+
+    def quick_probes(self) -> List[Probe]:
+        """获取快速探针：priority <= 2"""
+        return self.filter(max_priority=2)
+
+    # ── 执行 ──
+    def run(self, probes: List[Probe] = None) -> List[TestError]:
+        """批量执行探针
+
+        Args:
+            probes: 要执行的探针列表。None 表示全部。
+
+        Ctrl+C 处理：
+            中断后保留已完成的结果，打印部分汇总后退出。
+        """
+        targets = probes if probes is not None else self._probes
+        results = []
+        total = len(targets)
+        interrupted = False
+
+        self.log.section(f"📍 探针扫描 — {total} 个检测点")
+
+        try:
+            for i, probe in enumerate(targets, 1):
+                tag_str = f"[{probe.category}]" if probe.category else ""
+                self.log.info(f"[{i}/{total}] {tag_str} 探针: {probe.name}")
+
+                try:
+                    result = probe.run()
+                except KeyboardInterrupt:
+                    raise  # 重新抛出给外层 catch
+                self.log.print_result(result.error_code, result.test_name)
+                self.log.error(result)
+                results.append(result)
+
+        except KeyboardInterrupt:
+            interrupted = True
+            remaining = total - len(results)
+            self.log.section("⚠️  用户中断 (Ctrl+C)")
+            self.log.warning(f"已执行 {len(results)}/{total} 个探针，剩余 {remaining} 个未执行")
+            self.log.print_colored(f"\n⚠️  用户中断 — 已扫描 {len(results)}/{total} 个探针", bold=True)
+
+        passed = sum(1 for r in results if r.error_code.category == ErrorCategory.PASS)
+        failed = len(results) - passed
+
+        if interrupted:
+            self.log.info(f"中断前结果: {passed}/{len(results)} 通过, {failed} 失败")
+        else:
+            self.log.info(f"探针扫描完成: {passed}/{total} 通过, {failed} 失败")
+
+        return results
+
+    def run_smoke(self) -> List[TestError]:
+        """执行冒烟测试（仅 priority=1 的关键探针）"""
+        probes = self.smoke_probes()
+        self.log.section("🔥 冒烟测试 — 关键路径检测")
+        return self.run(probes)
+
+    def run_category(self, category: str) -> List[TestError]:
+        """按分类执行探针"""
+        probes = self.filter(category=category)
+        self.log.section(f"📍 分类扫描: {category}")
+        return self.run(probes)
+
+    # ── 快捷探针工厂 ──
+    @staticmethod
+    def simple(name: str, condition: bool, detail: str = "",
+               category: str = "通用", priority: int = 3,
+               tags: Set[str] = None) -> Probe:
+        """快速创建条件探针
+
+        Args:
+            name: 探针名称
+            condition: 检查条件（True = 通过）
+            detail: 详情描述
+            category: 分类
+            priority: 优先级
+            tags: 标签
+        """
+        return Probe(
+            name=name,
+            check=lambda c=condition, d=detail: (c, d if d else f"条件{'满足' if c else '不满足'}"),
+            category=category,
+            priority=priority,
+            tags=tags or set(),
+        )