kdtest-pw 2.0.0__py3-none-any.whl

kdtest_pw/api/__init__.py

@@ -0,0 +1,6 @@
+"""API 测试模块"""
+
+from .request_handler import RequestHandler
+from .api_keyword import ApiKeyword
+
+__all__ = ['RequestHandler', 'ApiKeyword']

kdtest_pw/api/api_keyword.py

@@ -0,0 +1,251 @@
+"""API 测试关键字"""
+
+import json
+from typing import Any, Dict, Optional
+
+from .request_handler import RequestHandler
+from ..reference import INFO, set_element_value, get_element_value
+
+
+class ApiKeyword:
+    """API 测试关键字
+
+    提供 API 测试的关键字方法。
+    """
+
+    def __init__(self, request_handler: RequestHandler = None):
+        """初始化 API 关键字
+
+        Args:
+            request_handler: 请求处理器
+        """
+        self._handler = request_handler or RequestHandler()
+
+    def api_set_base_url(self, *, content: str) -> None:
+        """设置基础 URL
+
+        Args:
+            content: 基础 URL
+        """
+        self._handler._base_url = content
+        INFO(f"设置基础 URL: {content}")
+
+    def api_set_header(self, *, content: str) -> None:
+        """设置请求头
+
+        Args:
+            content: JSON 格式的请求头 {"key": "value"}
+        """
+        headers = json.loads(content)
+        self._handler.set_default_headers(headers)
+        INFO(f"设置请求头: {list(headers.keys())}")
+
+    def api_get(self, *, content: str, key: str = None) -> Dict[str, Any]:
+        """GET 请求
+
+        Args:
+            content: URL 或 JSON 配置 {"url": "...", "params": {...}}
+            key: 响应缓存键名
+
+        Returns:
+            Dict: 响应数据
+        """
+        if content.startswith('{'):
+            config = json.loads(content)
+            url = config.get('url', '')
+            params = config.get('params')
+            headers = config.get('headers')
+            response = self._handler.get(url, params=params, headers=headers)
+        else:
+            response = self._handler.get(content)
+
+        if key:
+            set_element_value(key, response)
+
+        return response
+
+    def api_post(self, *, content: str, key: str = None) -> Dict[str, Any]:
+        """POST 请求
+
+        Args:
+            content: JSON 配置 {"url": "...", "data": {...}}
+            key: 响应缓存键名
+
+        Returns:
+            Dict: 响应数据
+        """
+        config = json.loads(content)
+        url = config.get('url', '')
+        data = config.get('data')
+        json_data = config.get('json')
+        headers = config.get('headers')
+
+        response = self._handler.post(url, data=data, json_data=json_data, headers=headers)
+
+        if key:
+            set_element_value(key, response)
+
+        return response
+
+    def api_put(self, *, content: str, key: str = None) -> Dict[str, Any]:
+        """PUT 请求
+
+        Args:
+            content: JSON 配置
+            key: 响应缓存键名
+
+        Returns:
+            Dict: 响应数据
+        """
+        config = json.loads(content)
+        url = config.get('url', '')
+        data = config.get('data')
+        json_data = config.get('json')
+        headers = config.get('headers')
+
+        response = self._handler.put(url, data=data, json_data=json_data, headers=headers)
+
+        if key:
+            set_element_value(key, response)
+
+        return response
+
+    def api_delete(self, *, content: str, key: str = None) -> Dict[str, Any]:
+        """DELETE 请求
+
+        Args:
+            content: URL 或 JSON 配置
+            key: 响应缓存键名
+
+        Returns:
+            Dict: 响应数据
+        """
+        if content.startswith('{'):
+            config = json.loads(content)
+            url = config.get('url', '')
+            headers = config.get('headers')
+            response = self._handler.delete(url, headers=headers)
+        else:
+            response = self._handler.delete(content)
+
+        if key:
+            set_element_value(key, response)
+
+        return response
+
+    def api_status_assert(self, *, content: str) -> bool:
+        """断言响应状态码
+
+        Args:
+            content: 期望的状态码
+
+        Returns:
+            bool: 断言结果
+        """
+        response = self._handler.last_response
+        if not response:
+            INFO("没有响应数据", "ERROR")
+            return False
+
+        expected = int(content)
+        actual = response.get('status')
+        result = actual == expected
+
+        INFO(f"状态码断言: {actual} == {expected} -> {result}")
+        return result
+
+    def api_json_assert(self, *, content: str, path: str, mode: str = 'equals') -> bool:
+        """断言响应 JSON 字段
+
+        Args:
+            content: 期望值
+            path: JSON 路径 (如 "data.user.name")
+            mode: 断言模式
+
+        Returns:
+            bool: 断言结果
+        """
+        response = self._handler.last_response
+        if not response or 'json' not in response:
+            INFO("没有 JSON 响应数据", "ERROR")
+            return False
+
+        # 获取实际值
+        actual = self._get_json_value(response['json'], path)
+
+        # 断言
+        if mode == 'equals':
+            result = str(actual) == content
+        elif mode == 'contains':
+            result = content in str(actual)
+        elif mode == 'exists':
+            result = actual is not None
+        elif mode == 'not_exists':
+            result = actual is None
+        else:
+            result = str(actual) == content
+
+        INFO(f"JSON 断言: {path}='{actual}' {mode} '{content}' -> {result}")
+        return result
+
+    def api_extract_value(self, *, content: str, path: str) -> Any:
+        """提取响应值并缓存
+
+        Args:
+            content: 缓存键名
+            path: JSON 路径
+
+        Returns:
+            提取的值
+        """
+        response = self._handler.last_response
+        if not response or 'json' not in response:
+            INFO("没有 JSON 响应数据", "ERROR")
+            return None
+
+        value = self._get_json_value(response['json'], path)
+        set_element_value(content, value)
+
+        INFO(f"提取值: {content} = {path} -> {value}")
+        return value
+
+    def api_get_response(self, *, content: str) -> Optional[Dict[str, Any]]:
+        """获取缓存的响应
+
+        Args:
+            content: 缓存键名
+
+        Returns:
+            响应数据
+        """
+        return get_element_value(content)
+
+    def _get_json_value(self, data: Any, path: str) -> Any:
+        """从 JSON 获取值
+
+        Args:
+            data: JSON 数据
+            path: 路径 (支持点号和数组索引)
+
+        Returns:
+            值
+        """
+        keys = path.replace('[', '.').replace(']', '').split('.')
+        value = data
+
+        for key in keys:
+            if not key:
+                continue
+
+            if isinstance(value, dict):
+                value = value.get(key)
+            elif isinstance(value, list) and key.isdigit():
+                index = int(key)
+                value = value[index] if 0 <= index < len(value) else None
+            else:
+                return None
+
+            if value is None:
+                return None
+
+        return value

kdtest_pw/api/request_handler.py

@@ -0,0 +1,232 @@
+"""API 请求处理器"""
+
+from typing import Dict, Any, Optional
+from playwright.sync_api import APIRequestContext, BrowserContext
+
+from ..reference import GSTORE, INFO, set_element_value
+
+
+class RequestHandler:
+    """API 请求处理器
+
+    使用 Playwright 的 APIRequestContext 发送 HTTP 请求。
+    """
+
+    def __init__(self, context: Optional[BrowserContext] = None, base_url: str = ''):
+        """初始化请求处理器
+
+        Args:
+            context: BrowserContext 实例
+            base_url: 基础 URL
+        """
+        self._context = context or GSTORE.get('context')
+        self._base_url = base_url
+        self._request: Optional[APIRequestContext] = None
+        self._default_headers: Dict[str, str] = {}
+        self._last_response: Optional[Dict[str, Any]] = None
+
+    def create_request_context(
+        self,
+        base_url: str = None,
+        extra_headers: Dict[str, str] = None
+    ) -> None:
+        """创建请求上下文
+
+        Args:
+            base_url: 基础 URL
+            extra_headers: 额外请求头
+        """
+        if self._context:
+            options = {}
+            if base_url:
+                options['base_url'] = base_url
+            if extra_headers:
+                options['extra_http_headers'] = extra_headers
+
+            self._request = self._context.request
+
+    def set_default_headers(self, headers: Dict[str, str]) -> None:
+        """设置默认请求头
+
+        Args:
+            headers: 请求头字典
+        """
+        self._default_headers.update(headers)
+
+    def get(
+        self,
+        url: str,
+        params: Dict[str, Any] = None,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """GET 请求
+
+        Args:
+            url: 请求 URL
+            params: 查询参数
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        return self._request_method('get', url, params=params, headers=headers)
+
+    def post(
+        self,
+        url: str,
+        data: Any = None,
+        json_data: Dict = None,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """POST 请求
+
+        Args:
+            url: 请求 URL
+            data: 表单数据
+            json_data: JSON 数据
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        return self._request_method('post', url, data=data, json_data=json_data, headers=headers)
+
+    def put(
+        self,
+        url: str,
+        data: Any = None,
+        json_data: Dict = None,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """PUT 请求
+
+        Args:
+            url: 请求 URL
+            data: 表单数据
+            json_data: JSON 数据
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        return self._request_method('put', url, data=data, json_data=json_data, headers=headers)
+
+    def delete(
+        self,
+        url: str,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """DELETE 请求
+
+        Args:
+            url: 请求 URL
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        return self._request_method('delete', url, headers=headers)
+
+    def patch(
+        self,
+        url: str,
+        data: Any = None,
+        json_data: Dict = None,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """PATCH 请求
+
+        Args:
+            url: 请求 URL
+            data: 表单数据
+            json_data: JSON 数据
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        return self._request_method('patch', url, data=data, json_data=json_data, headers=headers)
+
+    def _request_method(
+        self,
+        method: str,
+        url: str,
+        params: Dict[str, Any] = None,
+        data: Any = None,
+        json_data: Dict = None,
+        headers: Dict[str, str] = None
+    ) -> Dict[str, Any]:
+        """发送请求
+
+        Args:
+            method: 请求方法
+            url: 请求 URL
+            params: 查询参数
+            data: 表单数据
+            json_data: JSON 数据
+            headers: 请求头
+
+        Returns:
+            Dict: 响应数据
+        """
+        if not self._request and self._context:
+            self._request = self._context.request
+
+        if not self._request:
+            raise RuntimeError("请求上下文未初始化")
+
+        # 合并请求头
+        final_headers = {**self._default_headers}
+        if headers:
+            final_headers.update(headers)
+
+        # 构建完整 URL
+        full_url = f"{self._base_url}{url}" if self._base_url and not url.startswith('http') else url
+
+        # 构建请求参数
+        request_kwargs = {
+            'headers': final_headers if final_headers else None,
+        }
+
+        if params:
+            request_kwargs['params'] = params
+        if data:
+            request_kwargs['data'] = data
+        if json_data:
+            request_kwargs['data'] = json_data
+
+        INFO(f"API {method.upper()}: {full_url}")
+
+        # 发送请求
+        request_method = getattr(self._request, method)
+        response = request_method(full_url, **{k: v for k, v in request_kwargs.items() if v is not None})
+
+        # 解析响应
+        result = {
+            'status': response.status,
+            'status_text': response.status_text,
+            'headers': dict(response.headers),
+            'url': response.url,
+        }
+
+        # 尝试解析 JSON
+        try:
+            result['json'] = response.json()
+        except Exception:
+            result['text'] = response.text()
+
+        self._last_response = result
+        INFO(f"API 响应: {response.status} {response.status_text}")
+
+        return result
+
+    @property
+    def last_response(self) -> Optional[Dict[str, Any]]:
+        """获取最后一次响应"""
+        return self._last_response
+
+    def dispose(self) -> None:
+        """释放资源"""
+        if self._request:
+            self._request.dispose()
+            self._request = None

kdtest_pw/cases/__init__.py

@@ -0,0 +1,6 @@
+"""测试用例模块"""
+
+from .case_collector import CaseCollector
+from .case_executor import CaseExecutor
+
+__all__ = ['CaseCollector', 'CaseExecutor']

kdtest_pw/cases/case_collector.py

@@ -0,0 +1,182 @@
+"""测试用例收集器"""
+
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+
+from .read.excel_reader import ExcelReader, TestCase, TestStep
+from ..reference import INFO
+
+
+class CaseCollector:
+    """测试用例收集器
+
+    从配置和 Excel 文件收集测试用例。
+    """
+
+    def __init__(self, config: Dict[str, Any] = None):
+        """初始化用例收集器
+
+        Args:
+            config: 配置字典
+        """
+        self._config = config or {}
+        self._cases: List[TestCase] = []
+        self._case_files: List[Dict[str, Any]] = []
+
+    def add_case_file(
+        self,
+        file_path: str,
+        sheets: List[str] = None,
+        interface_switch: bool = False
+    ) -> None:
+        """添加测试用例文件
+
+        Args:
+            file_path: Excel 文件路径
+            sheets: 要执行的 Sheet 列表，None 表示全部
+            interface_switch: 是否接口测试
+        """
+        self._case_files.append({
+            'path': file_path,
+            'sheets': sheets,
+            'interface': interface_switch
+        })
+
+    def collect(self) -> List[TestCase]:
+        """收集所有测试用例
+
+        Returns:
+            List[TestCase]: 测试用例列表
+        """
+        self._cases.clear()
+
+        # 从配置收集
+        if 'testCaseFile' in self._config:
+            for file_config in self._config['testCaseFile']:
+                self.add_case_file(
+                    file_path=file_config.get('caseFilePath', ''),
+                    sheets=file_config.get('caseItem'),
+                    interface_switch=file_config.get('interfaceSwitch', False)
+                )
+
+        # 收集用例
+        for file_info in self._case_files:
+            self._collect_from_file(file_info)
+
+        INFO(f"共收集 {len(self._cases)} 个测试用例")
+        return self._cases
+
+    def _collect_from_file(self, file_info: Dict[str, Any]) -> None:
+        """从文件收集用例
+
+        Args:
+            file_info: 文件信息
+        """
+        file_path = file_info['path']
+        sheets = file_info['sheets']
+
+        if not Path(file_path).exists():
+            INFO(f"用例文件不存在: {file_path}", "WARNING")
+            return
+
+        try:
+            with ExcelReader(file_path) as reader:
+                if sheets:
+                    # 只读取指定 Sheet
+                    all_cases = reader.read_all_sheets(sheets)
+                else:
+                    # 读取所有 Sheet
+                    all_cases = reader.read_all_sheets()
+
+                for sheet_name, cases in all_cases.items():
+                    for case_data in cases:
+                        case_data['file'] = file_path
+                        case_data['interface'] = file_info['interface']
+                        self._cases.append(TestCase(case_data))
+
+        except Exception as e:
+            INFO(f"读取用例文件失败: {file_path} - {e}", "ERROR")
+
+    @property
+    def cases(self) -> List[TestCase]:
+        """获取所有测试用例"""
+        return self._cases.copy()
+
+    @property
+    def case_count(self) -> int:
+        """获取用例数量"""
+        return len(self._cases)
+
+    def get_cases_by_sheet(self, sheet_name: str) -> List[TestCase]:
+        """按 Sheet 获取用例
+
+        Args:
+            sheet_name: Sheet 名称
+
+        Returns:
+            List[TestCase]: 匹配的用例列表
+        """
+        return [c for c in self._cases if c.sheet == sheet_name]
+
+    def get_cases_by_name(self, name_pattern: str) -> List[TestCase]:
+        """按名称模式获取用例
+
+        Args:
+            name_pattern: 名称模式（支持通配符 *）
+
+        Returns:
+            List[TestCase]: 匹配的用例列表
+        """
+        import fnmatch
+        return [c for c in self._cases if fnmatch.fnmatch(c.name, name_pattern)]
+
+    def get_cases_by_id(self, case_ids: List[str]) -> List[TestCase]:
+        """按 ID 获取用例
+
+        Args:
+            case_ids: 用例 ID 列表
+
+        Returns:
+            List[TestCase]: 匹配的用例列表
+        """
+        return [c for c in self._cases if c.id in case_ids]
+
+    def filter_cases(
+        self,
+        include_sheets: List[str] = None,
+        exclude_sheets: List[str] = None,
+        include_ids: List[str] = None,
+        exclude_ids: List[str] = None,
+        name_pattern: str = None
+    ) -> List[TestCase]:
+        """过滤用例
+
+        Args:
+            include_sheets: 包含的 Sheet
+            exclude_sheets: 排除的 Sheet
+            include_ids: 包含的 ID
+            exclude_ids: 排除的 ID
+            name_pattern: 名称模式
+
+        Returns:
+            List[TestCase]: 过滤后的用例列表
+        """
+        result = self._cases.copy()
+
+        if include_sheets:
+            result = [c for c in result if c.sheet in include_sheets]
+
+        if exclude_sheets:
+            result = [c for c in result if c.sheet not in exclude_sheets]
+
+        if include_ids:
+            result = [c for c in result if c.id in include_ids]
+
+        if exclude_ids:
+            result = [c for c in result if c.id not in exclude_ids]
+
+        if name_pattern:
+            import fnmatch
+            result = [c for c in result if fnmatch.fnmatch(c.name, name_pattern)]
+
+        return result