kdtest-pw 2.0.0__py3-none-any.whl

kdtest_pw/cases/case_executor.py

@@ -0,0 +1,359 @@
+"""用例执行引擎"""
+
+import time
+import traceback
+from typing import Dict, Any, Optional, List, Callable
+from datetime import datetime
+from pathlib import Path
+
+from .read.excel_reader import TestCase, TestStep
+from .read.cell_handler import CellHandler
+from ..action.key_retrieval import KeyRetrieval
+from ..reference import (
+    GSTORE, PRIVATEDATA, CASESDATA, INFO,
+    set_element_value, clear_element_values
+)
+
+
+class StepResult:
+    """步骤执行结果"""
+
+    def __init__(self, step: TestStep):
+        self.step = step
+        self.status: str = 'pending'  # pending, passed, failed, skipped
+        self.start_time: Optional[datetime] = None
+        self.end_time: Optional[datetime] = None
+        self.duration: float = 0
+        self.error: Optional[str] = None
+        self.screenshot: Optional[str] = None
+
+    @property
+    def is_passed(self) -> bool:
+        return self.status == 'passed'
+
+    @property
+    def is_failed(self) -> bool:
+        return self.status == 'failed'
+
+
+class CaseResult:
+    """用例执行结果"""
+
+    def __init__(self, case: TestCase):
+        self.case = case
+        self.status: str = 'pending'  # pending, passed, failed, skipped
+        self.start_time: Optional[datetime] = None
+        self.end_time: Optional[datetime] = None
+        self.duration: float = 0
+        self.step_results: List[StepResult] = []
+        self.error: Optional[str] = None
+
+    @property
+    def is_passed(self) -> bool:
+        return self.status == 'passed'
+
+    @property
+    def is_failed(self) -> bool:
+        return self.status == 'failed'
+
+    @property
+    def passed_steps(self) -> int:
+        return sum(1 for s in self.step_results if s.is_passed)
+
+    @property
+    def failed_steps(self) -> int:
+        return sum(1 for s in self.step_results if s.is_failed)
+
+
+class CaseExecutor:
+    """用例执行引擎
+
+    执行测试用例，管理执行流程和结果收集。
+    """
+
+    def __init__(
+        self,
+        key_retrieval: KeyRetrieval = None,
+        cell_handler: CellHandler = None,
+        retry_count: int = 0,
+        screenshot_on_fail: bool = True,
+        stop_on_fail: bool = False
+    ):
+        """初始化执行引擎
+
+        Args:
+            key_retrieval: 关键字分发器
+            cell_handler: 单元格处理器
+            retry_count: 失败重试次数
+            screenshot_on_fail: 失败时是否截图
+            stop_on_fail: 失败时是否停止
+        """
+        self._key_retrieval = key_retrieval or KeyRetrieval()
+        self._cell_handler = cell_handler or CellHandler()
+        self._retry_count = retry_count
+        self._screenshot_on_fail = screenshot_on_fail
+        self._stop_on_fail = stop_on_fail
+
+        self._results: List[CaseResult] = []
+        self._current_case: Optional[TestCase] = None
+        self._current_result: Optional[CaseResult] = None
+
+        # 回调
+        self._on_case_start: Optional[Callable] = None
+        self._on_case_end: Optional[Callable] = None
+        self._on_step_start: Optional[Callable] = None
+        self._on_step_end: Optional[Callable] = None
+
+    def set_callbacks(
+        self,
+        on_case_start: Callable = None,
+        on_case_end: Callable = None,
+        on_step_start: Callable = None,
+        on_step_end: Callable = None
+    ) -> None:
+        """设置回调函数
+
+        Args:
+            on_case_start: 用例开始回调
+            on_case_end: 用例结束回调
+            on_step_start: 步骤开始回调
+            on_step_end: 步骤结束回调
+        """
+        self._on_case_start = on_case_start
+        self._on_case_end = on_case_end
+        self._on_step_start = on_step_start
+        self._on_step_end = on_step_end
+
+    def execute_cases(self, cases: List[TestCase]) -> List[CaseResult]:
+        """执行多个用例
+
+        Args:
+            cases: 用例列表
+
+        Returns:
+            List[CaseResult]: 执行结果列表
+        """
+        self._results.clear()
+        CASESDATA['total'] = len(cases)
+        CASESDATA['passed'] = 0
+        CASESDATA['failed'] = 0
+        CASESDATA['skipped'] = 0
+
+        INFO(f"开始执行 {len(cases)} 个用例")
+
+        for case in cases:
+            result = self.execute_case(case)
+            self._results.append(result)
+
+            if result.is_passed:
+                CASESDATA['passed'] += 1
+            elif result.is_failed:
+                CASESDATA['failed'] += 1
+                if self._stop_on_fail:
+                    INFO("用例失败，停止执行", "WARNING")
+                    break
+            else:
+                CASESDATA['skipped'] += 1
+
+        INFO(f"执行完成: 通过 {CASESDATA['passed']}, 失败 {CASESDATA['failed']}, 跳过 {CASESDATA['skipped']}")
+        return self._results
+
+    def execute_case(self, case: TestCase) -> CaseResult:
+        """执行单个用例
+
+        Args:
+            case: 测试用例
+
+        Returns:
+            CaseResult: 执行结果
+        """
+        self._current_case = case
+        self._current_result = CaseResult(case)
+        PRIVATEDATA['CURRENT_CASE'] = case.name
+
+        INFO(f"执行用例: [{case.id}] {case.name}")
+
+        # 回调
+        if self._on_case_start:
+            self._on_case_start(case)
+
+        self._current_result.start_time = datetime.now()
+
+        # 清除上一个用例的缓存
+        clear_element_values()
+
+        try:
+            # 执行所有步骤
+            for step in case.steps:
+                step_result = self._execute_step_with_retry(step)
+                self._current_result.step_results.append(step_result)
+
+                if step_result.is_failed and self._stop_on_fail:
+                    break
+
+            # 判断用例结果
+            if any(s.is_failed for s in self._current_result.step_results):
+                self._current_result.status = 'failed'
+            else:
+                self._current_result.status = 'passed'
+
+        except Exception as e:
+            self._current_result.status = 'failed'
+            self._current_result.error = str(e)
+            INFO(f"用例执行异常: {e}", "ERROR")
+
+        self._current_result.end_time = datetime.now()
+        self._current_result.duration = (
+            self._current_result.end_time - self._current_result.start_time
+        ).total_seconds()
+
+        status_text = '通过' if self._current_result.is_passed else '失败'
+        INFO(f"用例完成: [{case.id}] {case.name} - {status_text} ({self._current_result.duration:.2f}s)")
+
+        # 回调
+        if self._on_case_end:
+            self._on_case_end(case, self._current_result)
+
+        return self._current_result
+
+    def _execute_step_with_retry(self, step: TestStep) -> StepResult:
+        """执行步骤（带重试）
+
+        Args:
+            step: 测试步骤
+
+        Returns:
+            StepResult: 步骤结果
+        """
+        result = None
+        retry = 0
+
+        while retry <= self._retry_count:
+            result = self._execute_step(step)
+
+            if result.is_passed:
+                break
+
+            if retry < self._retry_count:
+                INFO(f"步骤失败，第 {retry + 1} 次重试...", "WARNING")
+                retry += 1
+            else:
+                break
+
+        return result
+
+    def _execute_step(self, step: TestStep) -> StepResult:
+        """执行单个步骤
+
+        Args:
+            step: 测试步骤
+
+        Returns:
+            StepResult: 步骤结果
+        """
+        result = StepResult(step)
+
+        # 回调
+        if self._on_step_start:
+            self._on_step_start(step)
+
+        result.start_time = datetime.now()
+
+        try:
+            # 处理定位信息
+            locator_info = []
+            for loc in step.locator:
+                processed = self._cell_handler.process(loc)
+                if processed:
+                    locator_info.append(processed)
+
+            # 处理操作值
+            value = self._cell_handler.process(step.value) if step.value else None
+
+            # 执行关键字
+            INFO(f"  步骤: {step.description or step.keyword}")
+            exec_result = self._key_retrieval.execute(
+                keyword=step.keyword,
+                locator_info=locator_info,
+                value=value
+            )
+
+            # 处理断言关键字返回值
+            if step.keyword.endswith('_assert') or step.keyword.startswith('assert'):
+                if exec_result is False:
+                    raise AssertionError(f"断言失败: {step.keyword}")
+
+            result.status = 'passed'
+
+        except Exception as e:
+            result.status = 'failed'
+            result.error = str(e)
+            INFO(f"  步骤失败: {e}", "ERROR")
+
+            # 失败截图
+            if self._screenshot_on_fail:
+                result.screenshot = self._take_screenshot(step)
+
+        result.end_time = datetime.now()
+        result.duration = (result.end_time - result.start_time).total_seconds()
+
+        # 回调
+        if self._on_step_end:
+            self._on_step_end(step, result)
+
+        return result
+
+    def _take_screenshot(self, step: TestStep) -> Optional[str]:
+        """失败截图
+
+        Args:
+            step: 测试步骤
+
+        Returns:
+            str: 截图路径
+        """
+        try:
+            page = GSTORE.get('page')
+            if not page:
+                return None
+
+            # 生成截图文件名
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            case_name = self._current_case.name if self._current_case else 'unknown'
+            # 移除非法字符
+            case_name = ''.join(c for c in case_name if c.isalnum() or c in ('_', '-'))
+
+            screenshot_dir = Path('result/screenshot')
+            screenshot_dir.mkdir(parents=True, exist_ok=True)
+
+            screenshot_path = screenshot_dir / f"{case_name}_{step.row}_{timestamp}.png"
+            page.screenshot(path=str(screenshot_path))
+
+            INFO(f"  截图已保存: {screenshot_path}")
+            return str(screenshot_path)
+
+        except Exception as e:
+            INFO(f"  截图失败: {e}", "WARNING")
+            return None
+
+    @property
+    def results(self) -> List[CaseResult]:
+        """获取所有执行结果"""
+        return self._results.copy()
+
+    @property
+    def summary(self) -> Dict[str, Any]:
+        """获取执行摘要"""
+        total = len(self._results)
+        passed = sum(1 for r in self._results if r.is_passed)
+        failed = sum(1 for r in self._results if r.is_failed)
+        duration = sum(r.duration for r in self._results)
+
+        return {
+            'total': total,
+            'passed': passed,
+            'failed': failed,
+            'skipped': total - passed - failed,
+            'pass_rate': (passed / total * 100) if total > 0 else 0,
+            'duration': duration,
+        }

kdtest_pw/cases/read/__init__.py

@@ -0,0 +1,6 @@
+"""Excel 读取模块"""
+
+from .excel_reader import ExcelReader
+from .cell_handler import CellHandler
+
+__all__ = ['ExcelReader', 'CellHandler']

kdtest_pw/cases/read/cell_handler.py

@@ -0,0 +1,305 @@
+"""单元格值处理器"""
+
+import re
+from typing import Any, Optional, Dict
+from datetime import datetime, timedelta
+
+from ...reference import PRIVATEDATA, GSDSTORE, get_element_value, INFO
+
+
+class CellHandler:
+    """单元格值处理器
+
+    处理 Excel 单元格中的特殊语法，如变量引用、内置函数等。
+    """
+
+    # 变量引用模式: ${varName} 或 ${module.varName}
+    VAR_PATTERN = re.compile(r'\$\{([^}]+)\}')
+
+    # 内置函数模式: @func(args) 或 @func()
+    FUNC_PATTERN = re.compile(r'@(\w+)\(([^)]*)\)')
+
+    def __init__(self, custom_params: Dict[str, Any] = None):
+        """初始化处理器
+
+        Args:
+            custom_params: 自定义参数字典
+        """
+        self._custom_params = custom_params or {}
+
+        # 注册内置函数
+        self._functions = {
+            'today': self._func_today,
+            'now': self._func_now,
+            'date': self._func_date,
+            'random': self._func_random,
+            'random_str': self._func_random_str,
+            'random_phone': self._func_random_phone,
+            'random_email': self._func_random_email,
+            'uuid': self._func_uuid,
+            'timestamp': self._func_timestamp,
+            'env': self._func_env,
+        }
+
+    def process(self, value: Any) -> Any:
+        """处理单元格值
+
+        Args:
+            value: 原始值
+
+        Returns:
+            处理后的值
+        """
+        if value is None:
+            return None
+
+        value_str = str(value)
+
+        # 处理变量引用
+        value_str = self._process_variables(value_str)
+
+        # 处理内置函数
+        value_str = self._process_functions(value_str)
+
+        return value_str
+
+    def _process_variables(self, value: str) -> str:
+        """处理变量引用
+
+        支持格式:
+        - ${varName} - 从元素值缓存获取
+        - ${self.param} - 从自定义参数获取
+        - ${env.name} - 从环境变量获取
+
+        Args:
+            value: 原始值
+
+        Returns:
+            处理后的值
+        """
+        def replace_var(match):
+            var_path = match.group(1)
+
+            # 检查是否有命名空间
+            if '.' in var_path:
+                namespace, var_name = var_path.split('.', 1)
+
+                if namespace == 'self':
+                    # 自定义参数
+                    return str(self._custom_params.get(var_name, match.group(0)))
+                elif namespace == 'env':
+                    # 环境变量
+                    import os
+                    return os.environ.get(var_name, match.group(0))
+                elif namespace == 'ele':
+                    # 元素值缓存
+                    return str(get_element_value(var_name, match.group(0)))
+
+            # 默认从元素值缓存获取
+            cached = get_element_value(var_path)
+            if cached is not None:
+                return str(cached)
+
+            # 从自定义参数获取
+            if var_path in self._custom_params:
+                return str(self._custom_params[var_path])
+
+            # 返回原始匹配
+            return match.group(0)
+
+        return self.VAR_PATTERN.sub(replace_var, value)
+
+    def _process_functions(self, value: str) -> str:
+        """处理内置函数
+
+        支持格式:
+        - @today() - 今天日期
+        - @now() - 当前时间
+        - @random(min, max) - 随机数
+        - @uuid() - UUID
+
+        Args:
+            value: 原始值
+
+        Returns:
+            处理后的值
+        """
+        def replace_func(match):
+            func_name = match.group(1)
+            args_str = match.group(2).strip()
+
+            # 解析参数
+            args = []
+            if args_str:
+                args = [a.strip().strip('"\'') for a in args_str.split(',')]
+
+            # 调用函数
+            if func_name in self._functions:
+                try:
+                    return str(self._functions[func_name](*args))
+                except Exception as e:
+                    INFO(f"函数执行失败: @{func_name}({args_str}) - {e}", "WARNING")
+                    return match.group(0)
+
+            return match.group(0)
+
+        return self.FUNC_PATTERN.sub(replace_func, value)
+
+    # ==================== 内置函数 ====================
+
+    def _func_today(self, fmt: str = '%Y-%m-%d', offset: str = '0') -> str:
+        """获取今天日期
+
+        Args:
+            fmt: 日期格式
+            offset: 天数偏移
+
+        Returns:
+            str: 格式化的日期
+        """
+        date = datetime.now() + timedelta(days=int(offset))
+        return date.strftime(fmt)
+
+    def _func_now(self, fmt: str = '%Y-%m-%d %H:%M:%S') -> str:
+        """获取当前时间
+
+        Args:
+            fmt: 时间格式
+
+        Returns:
+            str: 格式化的时间
+        """
+        return datetime.now().strftime(fmt)
+
+    def _func_date(self, fmt: str = '%Y-%m-%d', offset: str = '0', unit: str = 'days') -> str:
+        """获取日期
+
+        Args:
+            fmt: 日期格式
+            offset: 偏移量
+            unit: 单位 (days, hours, minutes, seconds)
+
+        Returns:
+            str: 格式化的日期
+        """
+        offset_int = int(offset)
+        kwargs = {unit: offset_int}
+        date = datetime.now() + timedelta(**kwargs)
+        return date.strftime(fmt)
+
+    def _func_random(self, min_val: str = '0', max_val: str = '100') -> int:
+        """生成随机整数
+
+        Args:
+            min_val: 最小值
+            max_val: 最大值
+
+        Returns:
+            int: 随机整数
+        """
+        import random
+        return random.randint(int(min_val), int(max_val))
+
+    def _func_random_str(self, length: str = '8', chars: str = 'alphanumeric') -> str:
+        """生成随机字符串
+
+        Args:
+            length: 长度
+            chars: 字符类型 (alpha, numeric, alphanumeric)
+
+        Returns:
+            str: 随机字符串
+        """
+        import random
+        import string
+
+        char_map = {
+            'alpha': string.ascii_letters,
+            'numeric': string.digits,
+            'alphanumeric': string.ascii_letters + string.digits,
+            'lower': string.ascii_lowercase,
+            'upper': string.ascii_uppercase,
+        }
+
+        charset = char_map.get(chars, string.ascii_letters + string.digits)
+        return ''.join(random.choices(charset, k=int(length)))
+
+    def _func_random_phone(self, prefix: str = '1') -> str:
+        """生成随机手机号
+
+        Args:
+            prefix: 号码前缀
+
+        Returns:
+            str: 随机手机号
+        """
+        import random
+        prefixes = ['13', '14', '15', '16', '17', '18', '19']
+        phone_prefix = random.choice(prefixes) if prefix == '1' else prefix
+        return phone_prefix + ''.join([str(random.randint(0, 9)) for _ in range(9)])
+
+    def _func_random_email(self, domain: str = 'test.com') -> str:
+        """生成随机邮箱
+
+        Args:
+            domain: 邮箱域名
+
+        Returns:
+            str: 随机邮箱
+        """
+        username = self._func_random_str('8', 'lower')
+        return f"{username}@{domain}"
+
+    def _func_uuid(self) -> str:
+        """生成 UUID
+
+        Returns:
+            str: UUID 字符串
+        """
+        import uuid
+        return str(uuid.uuid4())
+
+    def _func_timestamp(self, unit: str = 'ms') -> int:
+        """获取时间戳
+
+        Args:
+            unit: 单位 (s, ms)
+
+        Returns:
+            int: 时间戳
+        """
+        import time
+        ts = time.time()
+        if unit == 'ms':
+            return int(ts * 1000)
+        return int(ts)
+
+    def _func_env(self, name: str, default: str = '') -> str:
+        """获取环境变量
+
+        Args:
+            name: 环境变量名
+            default: 默认值
+
+        Returns:
+            str: 环境变量值
+        """
+        import os
+        return os.environ.get(name, default)
+
+    def register_function(self, name: str, func) -> None:
+        """注册自定义函数
+
+        Args:
+            name: 函数名
+            func: 函数对象
+        """
+        self._functions[name] = func
+
+    def set_custom_params(self, params: Dict[str, Any]) -> None:
+        """设置自定义参数
+
+        Args:
+            params: 参数字典
+        """
+        self._custom_params.update(params)