kdtest-pw 2.0.0__py3-none-any.whl

kdtest_pw/core/browser_manager.py

@@ -0,0 +1,196 @@
+"""Playwright 浏览器生命周期管理"""
+
+from playwright.sync_api import sync_playwright, Browser, BrowserContext, Page, Playwright
+from typing import Optional, Literal, Dict, Any
+from pathlib import Path
+
+from ..reference import GSTORE, INFO
+
+BrowserType = Literal["chromium", "firefox", "webkit"]
+
+
+class BrowserManager:
+    """Playwright 浏览器生命周期管理器
+
+    负责浏览器的启动、配置和关闭。
+    支持 chromium、firefox、webkit 三种浏览器。
+    支持 trace 录制和视频录制。
+    """
+
+    def __init__(self):
+        self._playwright: Optional[Playwright] = None
+        self._browser: Optional[Browser] = None
+        self._context: Optional[BrowserContext] = None
+        self._page: Optional[Page] = None
+        self._trace_enabled: bool = False
+        self._video_enabled: bool = False
+
+    def launch(
+        self,
+        browser_type: BrowserType = "chromium",
+        headless: bool = False,
+        slow_mo: int = 0,
+        trace: bool = False,
+        video: bool = False,
+        timeout: int = 30000,
+        viewport: Optional[Dict[str, int]] = None,
+        locale: str = "zh-CN",
+        timezone_id: str = "Asia/Shanghai",
+        **kwargs
+    ) -> Page:
+        """启动浏览器并返回页面
+
+        Args:
+            browser_type: 浏览器类型 (chromium, firefox, webkit)
+            headless: 是否无头模式
+            slow_mo: 操作延迟 (毫秒)
+            trace: 是否开启 trace 录制
+            video: 是否开启视频录制
+            timeout: 默认超时时间 (毫秒)
+            viewport: 视口大小 {"width": 1920, "height": 1080}
+            locale: 语言区域
+            timezone_id: 时区
+            **kwargs: 其他 Playwright 启动参数
+
+        Returns:
+            Page: Playwright 页面实例
+        """
+        INFO(f"启动浏览器: {browser_type}, headless={headless}")
+
+        self._playwright = sync_playwright().start()
+
+        # 选择浏览器类型
+        browser_launcher = getattr(self._playwright, browser_type)
+
+        # 浏览器启动参数
+        launch_options = {
+            'headless': headless,
+            'slow_mo': slow_mo,
+        }
+        launch_options.update(kwargs)
+
+        self._browser = browser_launcher.launch(**launch_options)
+
+        # 创建上下文参数
+        context_options: Dict[str, Any] = {
+            'locale': locale,
+            'timezone_id': timezone_id,
+        }
+
+        if viewport:
+            context_options['viewport'] = viewport
+        else:
+            context_options['viewport'] = {'width': 1920, 'height': 1080}
+
+        # 视频录制配置
+        if video:
+            self._video_enabled = True
+            video_dir = Path('result/video')
+            video_dir.mkdir(parents=True, exist_ok=True)
+            context_options['record_video_dir'] = str(video_dir)
+            context_options['record_video_size'] = {'width': 1920, 'height': 1080}
+            INFO("视频录制已启用")
+
+        self._context = self._browser.new_context(**context_options)
+
+        # 开启 trace 录制
+        if trace:
+            self._trace_enabled = True
+            self._context.tracing.start(
+                screenshots=True,
+                snapshots=True,
+                sources=True
+            )
+            INFO("Trace 录制已启用")
+
+        # 创建页面
+        self._page = self._context.new_page()
+
+        # 设置默认超时
+        self._page.set_default_timeout(timeout)
+        self._page.set_default_navigation_timeout(timeout)
+
+        # 更新全局存储
+        GSTORE['browser'] = self._browser
+        GSTORE['context'] = self._context
+        GSTORE['page'] = self._page
+
+        INFO("浏览器启动成功")
+        return self._page
+
+    def new_page(self) -> Page:
+        """创建新页面
+
+        Returns:
+            Page: 新的页面实例
+        """
+        if not self._context:
+            raise RuntimeError("浏览器上下文未初始化")
+
+        page = self._context.new_page()
+        return page
+
+    def close(self, save_trace: Optional[str] = None) -> None:
+        """关闭浏览器
+
+        Args:
+            save_trace: trace 文件保存路径 (如果开启了 trace)
+        """
+        INFO("关闭浏览器...")
+
+        # 保存 trace
+        if self._trace_enabled and self._context and save_trace:
+            trace_path = Path(save_trace)
+            trace_path.parent.mkdir(parents=True, exist_ok=True)
+            self._context.tracing.stop(path=str(trace_path))
+            INFO(f"Trace 已保存: {trace_path}")
+
+        # 关闭上下文
+        if self._context:
+            self._context.close()
+            self._context = None
+
+        # 关闭浏览器
+        if self._browser:
+            self._browser.close()
+            self._browser = None
+
+        # 停止 Playwright
+        if self._playwright:
+            self._playwright.stop()
+            self._playwright = None
+
+        # 清理全局存储
+        GSTORE['browser'] = None
+        GSTORE['context'] = None
+        GSTORE['page'] = None
+
+        INFO("浏览器已关闭")
+
+    @property
+    def page(self) -> Optional[Page]:
+        """当前页面实例"""
+        return self._page
+
+    @property
+    def context(self) -> Optional[BrowserContext]:
+        """浏览器上下文实例"""
+        return self._context
+
+    @property
+    def browser(self) -> Optional[Browser]:
+        """浏览器实例"""
+        return self._browser
+
+    @property
+    def is_running(self) -> bool:
+        """浏览器是否在运行"""
+        return self._browser is not None and self._browser.is_connected()
+
+    def __enter__(self) -> 'BrowserManager':
+        """上下文管理器入口"""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """上下文管理器出口"""
+        self.close()

kdtest_pw/core/config_loader.py

@@ -0,0 +1,235 @@
+"""配置加载器"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from ..common import DEFAULT_CONFIG
+from ..reference import GSDSTORE, INFO
+
+
+class ConfigLoader:
+    """配置加载器
+
+    支持 JSON 和 YAML 格式的配置文件。
+    """
+
+    def __init__(self, config_path: Optional[str] = None):
+        """初始化配置加载器
+
+        Args:
+            config_path: 配置文件路径，支持 .json 或 .yaml/.yml
+        """
+        self._config: Dict[str, Any] = DEFAULT_CONFIG.copy()
+        self._config_path: Optional[Path] = None
+
+        if config_path:
+            self.load(config_path)
+
+    def load(self, config_path: str) -> Dict[str, Any]:
+        """加载配置文件
+
+        Args:
+            config_path: 配置文件路径
+
+        Returns:
+            配置字典
+
+        Raises:
+            FileNotFoundError: 配置文件不存在
+            ValueError: 不支持的配置文件格式
+        """
+        path = Path(config_path)
+
+        if not path.exists():
+            raise FileNotFoundError(f"配置文件不存在: {config_path}")
+
+        self._config_path = path
+        suffix = path.suffix.lower()
+
+        if suffix == '.json':
+            config = self._load_json(path)
+        elif suffix in ('.yaml', '.yml'):
+            config = self._load_yaml(path)
+        else:
+            raise ValueError(f"不支持的配置文件格式: {suffix}")
+
+        # 合并配置
+        self._config.update(config)
+
+        # 处理相对路径
+        self._resolve_paths()
+
+        # 更新全局存储
+        GSDSTORE['START'] = self._config
+
+        INFO(f"配置已加载: {config_path}")
+        return self._config
+
+    def _load_json(self, path: Path) -> Dict[str, Any]:
+        """加载 JSON 配置文件"""
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def _load_yaml(self, path: Path) -> Dict[str, Any]:
+        """加载 YAML 配置文件"""
+        try:
+            import yaml
+            with open(path, 'r', encoding='utf-8') as f:
+                return yaml.safe_load(f) or {}
+        except ImportError:
+            INFO("PyYAML 未安装，无法加载 YAML 配置", "WARNING")
+            return {}
+
+    def _resolve_paths(self) -> None:
+        """解析配置中的相对路径"""
+        if not self._config_path:
+            return
+
+        base_dir = self._config_path.parent
+
+        # 处理测试用例文件路径
+        if 'testCaseFile' in self._config:
+            for case_file in self._config['testCaseFile']:
+                if 'caseFilePath' in case_file:
+                    case_path = Path(case_file['caseFilePath'])
+                    if not case_path.is_absolute():
+                        case_file['caseFilePath'] = str(base_dir / case_path)
+
+        # 存储工作路径
+        GSDSTORE['WORKPATH'] = {
+            'config_dir': str(base_dir),
+            'project_dir': str(base_dir.parent) if base_dir.name == 'data' else str(base_dir),
+        }
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        """获取配置字典"""
+        return self._config.copy()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """获取配置项
+
+        Args:
+            key: 配置键名，支持点号分隔的嵌套键 (如 "browser.headless")
+            default: 默认值
+
+        Returns:
+            配置值或默认值
+        """
+        keys = key.split('.')
+        value = self._config
+
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+            else:
+                return default
+
+            if value is None:
+                return default
+
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """设置配置项
+
+        Args:
+            key: 配置键名
+            value: 配置值
+        """
+        keys = key.split('.')
+
+        if len(keys) == 1:
+            self._config[key] = value
+        else:
+            # 处理嵌套键
+            target = self._config
+            for k in keys[:-1]:
+                if k not in target:
+                    target[k] = {}
+                target = target[k]
+            target[keys[-1]] = value
+
+    @property
+    def browser(self) -> str:
+        """浏览器类型"""
+        return self._config.get('browser', 'chromium')
+
+    @property
+    def headless(self) -> bool:
+        """是否无头模式"""
+        return self._config.get('headless', False)
+
+    @property
+    def slow_mo(self) -> int:
+        """操作延迟"""
+        return self._config.get('slowMo', 0)
+
+    @property
+    def timeout(self) -> int:
+        """默认超时"""
+        return self._config.get('timeout', 30000)
+
+    @property
+    def trace(self) -> bool:
+        """是否开启 trace"""
+        return self._config.get('trace', False)
+
+    @property
+    def video(self) -> bool:
+        """是否录制视频"""
+        return self._config.get('video', False)
+
+    @property
+    def url(self) -> Optional[str]:
+        """起始 URL"""
+        return self._config.get('url')
+
+    @property
+    def test_case_files(self) -> List[Dict[str, Any]]:
+        """测试用例文件配置"""
+        return self._config.get('testCaseFile', [])
+
+    @property
+    def self_defined_parameters(self) -> Dict[str, Any]:
+        """自定义参数"""
+        return self._config.get('selfDefinedParameter', {})
+
+    @property
+    def retry_switch(self) -> bool:
+        """是否开启重试"""
+        return self._config.get('retrySwitch', False)
+
+    @property
+    def retry_count(self) -> int:
+        """重试次数"""
+        return self._config.get('retryCount', 1)
+
+    def save(self, path: Optional[str] = None) -> None:
+        """保存配置到文件
+
+        Args:
+            path: 保存路径，默认为加载时的路径
+        """
+        save_path = Path(path) if path else self._config_path
+
+        if not save_path:
+            raise ValueError("未指定保存路径")
+
+        suffix = save_path.suffix.lower()
+
+        if suffix == '.json':
+            with open(save_path, 'w', encoding='utf-8') as f:
+                json.dump(self._config, f, indent=4, ensure_ascii=False)
+        elif suffix in ('.yaml', '.yml'):
+            try:
+                import yaml
+                with open(save_path, 'w', encoding='utf-8') as f:
+                    yaml.dump(self._config, f, default_flow_style=False, allow_unicode=True)
+            except ImportError:
+                INFO("PyYAML 未安装，无法保存 YAML 配置", "ERROR")
+                raise
+
+        INFO(f"配置已保存: {save_path}")

kdtest_pw/core/page_context.py

@@ -0,0 +1,228 @@
+"""页面上下文管理（多标签页支持）"""
+
+from playwright.sync_api import Page, BrowserContext
+from typing import Optional, List, Dict, Callable
+from ..reference import GSTORE, PRIVATEDATA, INFO
+
+
+class PageContext:
+    """页面上下文管理器
+
+    管理多标签页，支持页面切换、新页面监听等功能。
+    """
+
+    def __init__(self, context: Optional[BrowserContext] = None):
+        """初始化页面上下文管理器
+
+        Args:
+            context: BrowserContext 实例，如果不提供则从 GSTORE 获取
+        """
+        self._context = context or GSTORE.get('context')
+        self._pages: List[Page] = []
+        self._current_index: int = 0
+        self._page_handlers: Dict[str, Callable] = {}
+
+        if self._context:
+            # 初始化已有页面
+            self._pages = list(self._context.pages)
+
+            # 监听新页面
+            self._context.on('page', self._on_new_page)
+
+    def _on_new_page(self, page: Page) -> None:
+        """新页面事件处理
+
+        Args:
+            page: 新打开的页面
+        """
+        self._pages.append(page)
+        INFO(f"检测到新页面: {page.url}")
+
+        # 执行注册的处理器
+        for handler in self._page_handlers.values():
+            try:
+                handler(page)
+            except Exception as e:
+                INFO(f"页面处理器执行失败: {e}", "ERROR")
+
+    @property
+    def current_page(self) -> Optional[Page]:
+        """获取当前活动页面"""
+        if not self._pages:
+            return GSTORE.get('page')
+        return self._pages[self._current_index]
+
+    @property
+    def page_count(self) -> int:
+        """获取页面数量"""
+        return len(self._pages)
+
+    @property
+    def pages(self) -> List[Page]:
+        """获取所有页面"""
+        return self._pages.copy()
+
+    def switch_to_page(self, index: int) -> Page:
+        """切换到指定索引的页面
+
+        Args:
+            index: 页面索引 (支持负数索引)
+
+        Returns:
+            Page: 切换后的页面
+
+        Raises:
+            IndexError: 索引超出范围
+        """
+        if not self._pages:
+            raise IndexError("没有可用的页面")
+
+        # 处理负数索引
+        if index < 0:
+            index = len(self._pages) + index
+
+        if index < 0 or index >= len(self._pages):
+            raise IndexError(f"页面索引超出范围: {index}")
+
+        self._current_index = index
+        page = self._pages[index]
+
+        # 更新全局存储
+        GSTORE['page'] = page
+        PRIVATEDATA['PAGES'] = self._pages
+
+        INFO(f"切换到页面 {index}: {page.url}")
+        return page
+
+    def switch_to_new_page(self, timeout: int = 30000) -> Page:
+        """等待并切换到新打开的页面
+
+        Args:
+            timeout: 等待超时 (毫秒)
+
+        Returns:
+            Page: 新页面
+        """
+        if not self._context:
+            raise RuntimeError("浏览器上下文未初始化")
+
+        with self._context.expect_page(timeout=timeout) as new_page_info:
+            pass
+
+        new_page = new_page_info.value
+        new_page.wait_for_load_state('domcontentloaded')
+
+        # 更新页面列表
+        if new_page not in self._pages:
+            self._pages.append(new_page)
+
+        self._current_index = len(self._pages) - 1
+        GSTORE['page'] = new_page
+
+        INFO(f"切换到新页面: {new_page.url}")
+        return new_page
+
+    def switch_to_page_by_url(self, url_pattern: str) -> Optional[Page]:
+        """根据 URL 模式切换页面
+
+        Args:
+            url_pattern: URL 匹配模式 (支持部分匹配)
+
+        Returns:
+            Page: 匹配的页面，未找到返回 None
+        """
+        for i, page in enumerate(self._pages):
+            if url_pattern in page.url:
+                return self.switch_to_page(i)
+
+        INFO(f"未找到匹配的页面: {url_pattern}", "WARNING")
+        return None
+
+    def switch_to_page_by_title(self, title_pattern: str) -> Optional[Page]:
+        """根据标题模式切换页面
+
+        Args:
+            title_pattern: 标题匹配模式 (支持部分匹配)
+
+        Returns:
+            Page: 匹配的页面，未找到返回 None
+        """
+        for i, page in enumerate(self._pages):
+            if title_pattern in page.title():
+                return self.switch_to_page(i)
+
+        INFO(f"未找到匹配的页面: {title_pattern}", "WARNING")
+        return None
+
+    def close_current_page(self) -> Optional[Page]:
+        """关闭当前页面并切换到上一个页面
+
+        Returns:
+            Page: 切换后的当前页面，如果没有其他页面返回 None
+        """
+        if not self._pages:
+            return None
+
+        current = self._pages[self._current_index]
+        current.close()
+        self._pages.pop(self._current_index)
+
+        if not self._pages:
+            GSTORE['page'] = None
+            return None
+
+        # 切换到上一个页面
+        if self._current_index >= len(self._pages):
+            self._current_index = len(self._pages) - 1
+
+        new_current = self._pages[self._current_index]
+        GSTORE['page'] = new_current
+
+        INFO(f"关闭页面，切换到: {new_current.url}")
+        return new_current
+
+    def close_page(self, index: int) -> None:
+        """关闭指定索引的页面
+
+        Args:
+            index: 页面索引
+        """
+        if index < 0 or index >= len(self._pages):
+            raise IndexError(f"页面索引超出范围: {index}")
+
+        page = self._pages[index]
+        page.close()
+        self._pages.pop(index)
+
+        # 调整当前索引
+        if self._current_index >= len(self._pages):
+            self._current_index = max(0, len(self._pages) - 1)
+
+        if self._pages:
+            GSTORE['page'] = self._pages[self._current_index]
+        else:
+            GSTORE['page'] = None
+
+    def register_page_handler(self, name: str, handler: Callable[[Page], None]) -> None:
+        """注册新页面处理器
+
+        Args:
+            name: 处理器名称
+            handler: 处理函数，接收 Page 参数
+        """
+        self._page_handlers[name] = handler
+
+    def unregister_page_handler(self, name: str) -> None:
+        """注销页面处理器
+
+        Args:
+            name: 处理器名称
+        """
+        self._page_handlers.pop(name, None)
+
+    def refresh(self) -> None:
+        """刷新页面列表（同步上下文中的页面）"""
+        if self._context:
+            self._pages = list(self._context.pages)
+            if self._pages and self._current_index >= len(self._pages):
+                self._current_index = len(self._pages) - 1

kdtest_pw/data/__init__.py

@@ -0,0 +1,5 @@
+"""数据模块"""
+
+from .init_data import InitData
+
+__all__ = ['InitData']