pytest-dsl-ui 0.1.0__py3-none-any.whl

pytest_dsl_ui/__init__.py

@@ -0,0 +1,39 @@
+"""pytest-dsl-ui: Playwright-based UI automation keywords for pytest-dsl
+
+这个包为pytest-dsl框架提供基于Playwright的UI自动化测试关键字。
+通过entry_points机制自动集成到pytest-dsl中。
+"""
+
+__version__ = "0.1.0"
+__author__ = "Chen Shuanglin"
+
+from pytest_dsl.core.keyword_manager import keyword_manager
+
+
+def register_keywords(keyword_manager_instance=None):
+    """注册所有UI关键字到关键字管理器
+    
+    这个函数会被pytest-dsl的插件发现机制自动调用。
+    
+    Args:
+        keyword_manager_instance: 关键字管理器实例，如果为None则使用全局实例
+    """
+    if keyword_manager_instance is None:
+        keyword_manager_instance = keyword_manager
+    
+    # 导入所有关键字模块，触发关键字注册
+    try:
+        from . import keywords
+        print("pytest-dsl-ui: 已成功加载UI自动化关键字")
+    except ImportError as e:
+        print(f"pytest-dsl-ui: 加载关键字时出错: {e}")
+        raise
+
+
+# 当模块被直接导入时，自动注册关键字
+# 这确保了即使没有调用register_keywords函数，关键字也会被注册
+try:
+    from . import keywords
+except ImportError:
+    # 在某些情况下（如安装时），可能无法导入依赖
+    pass

pytest_dsl_ui/__main__.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+pytest-dsl-ui 包的主入口点
+
+支持通过 python -m pytest_dsl_ui 运行
+"""
+
+import sys
+import argparse
+from pathlib import Path
+
+
+def show_help():
+    """显示帮助信息"""
+    help_text = """
+pytest-dsl-ui 工具集
+
+用法:
+    python -m pytest_dsl_ui <command> [options]
+    
+命令:
+    convert      - 转换Playwright脚本为DSL格式
+    help         - 显示帮助信息
+    
+示例:
+    # 转换Playwright脚本
+    python -m pytest_dsl_ui convert script.py output.dsl
+    
+    # 显示帮助
+    python -m pytest_dsl_ui help
+    """
+    print(help_text.strip())
+
+
+def convert_command(args):
+    """处理转换命令"""
+    if len(args) < 1:
+        print("错误: convert命令需要输入文件")
+        print("用法: python -m pytest_dsl_ui convert <input_file> [output_file]")
+        return 1
+    
+    # 导入转换器
+    try:
+        from .utils.playwright_converter import PlaywrightToDSLConverter
+    except ImportError:
+        print("错误: 无法导入playwright_converter模块")
+        return 1
+    
+    input_file = args[0]
+    output_file = args[1] if len(args) > 1 else None
+    
+    # 检查输入文件
+    input_path = Path(input_file)
+    if not input_path.exists():
+        print(f"错误: 输入文件 {input_path} 不存在")
+        return 1
+    
+    try:
+        # 读取文件
+        with open(input_path, 'r', encoding='utf-8') as f:
+            script_content = f.read()
+        
+        # 转换
+        converter = PlaywrightToDSLConverter()
+        dsl_content = converter.convert_script(script_content)
+        
+        # 输出结果
+        if output_file:
+            output_path = Path(output_file)
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(dsl_content)
+            print(f"转换完成! DSL文件已保存到: {output_path}")
+        else:
+            print("转换结果:")
+            print("=" * 50)
+            print(dsl_content)
+        
+        return 0
+        
+    except Exception as e:
+        print(f"错误: {e}")
+        return 1
+
+
+def main():
+    """主函数"""
+    if len(sys.argv) < 2:
+        show_help()
+        return 0
+    
+    command = sys.argv[1]
+    args = sys.argv[2:]
+    
+    if command == 'convert':
+        return convert_command(args)
+    elif command == 'help':
+        show_help()
+        return 0
+    else:
+        print(f"错误: 未知命令 '{command}'")
+        show_help()
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main()) 

pytest_dsl_ui/core/__init__.py

@@ -0,0 +1 @@
+# Core modules for pytest-dsl-ui

pytest_dsl_ui/core/auth_manager.py

@@ -0,0 +1,248 @@
+"""认证状态管理器
+
+基于Playwright的storage_state功能，提供登录状态的保存和重用机制。
+参考: https://playwright.net.cn/python/docs/auth
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional
+from playwright.sync_api import BrowserContext
+
+logger = logging.getLogger(__name__)
+
+
+class AuthManager:
+    """认证状态管理器
+
+    提供登录状态的保存、加载和重用功能。
+    """
+
+    def __init__(self, auth_dir: str = "playwright/.auth"):
+        """初始化认证管理器
+
+        Args:
+            auth_dir: 认证状态文件存储目录
+        """
+        self.auth_dir = Path(auth_dir)
+        self.auth_dir.mkdir(parents=True, exist_ok=True)
+
+        # 确保.gitignore包含认证目录
+        self._ensure_gitignore()
+
+    def _ensure_gitignore(self):
+        """确保.gitignore包含认证目录"""
+        gitignore_path = Path(".gitignore")
+        auth_pattern = str(self.auth_dir)
+
+        if gitignore_path.exists():
+            with open(gitignore_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            if auth_pattern not in content:
+                with open(gitignore_path, 'a', encoding='utf-8') as f:
+                    f.write(f"\n# Playwright认证状态文件\n{auth_pattern}\n")
+                logger.info(f"已将 {auth_pattern} 添加到 .gitignore")
+        else:
+            with open(gitignore_path, 'w', encoding='utf-8') as f:
+                f.write(f"# Playwright认证状态文件\n{auth_pattern}\n")
+            logger.info(f"已创建 .gitignore 并添加 {auth_pattern}")
+
+    def save_auth_state(self, context: BrowserContext,
+                        state_name: str,
+                        metadata: Optional[Dict[str, Any]] = None,
+                        include_indexed_db: bool = True) -> str:
+        """保存认证状态
+
+        Args:
+            context: 已认证的浏览器上下文
+            state_name: 状态名称（用于标识不同的认证状态）
+            metadata: 元数据（如用户名、网站信息等）
+            include_indexed_db: 是否包含IndexedDB数据（Playwright 1.20+支持）
+
+        Returns:
+            str: 状态文件路径
+        """
+        try:
+            # 生成状态文件路径
+            state_file = self.auth_dir / f"{state_name}.json"
+
+            # 保存存储状态 - 根据Playwright版本支持IndexedDB
+            try:
+                if include_indexed_db:
+                    # 尝试使用IndexedDB选项（需要Playwright 1.20+）
+                    storage_state = context.storage_state(indexed_db=True)
+                    logger.info("使用IndexedDB支持保存认证状态")
+                else:
+                    storage_state = context.storage_state()
+                    logger.info("使用标准方式保存认证状态")
+            except TypeError as te:
+                # 旧版本Playwright不支持indexed_db参数
+                logger.warning(f"当前Playwright版本不支持IndexedDB选项: {str(te)}")
+                storage_state = context.storage_state()
+            except Exception as e:
+                logger.error(f"获取存储状态失败: {str(e)}")
+                raise
+
+            # 添加元数据
+            if metadata:
+                storage_state["metadata"] = metadata
+            
+            # 确保保存时间戳
+            storage_state["saved_at"] = self._get_timestamp()
+            
+            # 添加IndexedDB标识
+            storage_state["include_indexed_db"] = include_indexed_db
+
+            # 添加统计信息到元数据
+            stats = {
+                "cookies_count": len(storage_state.get("cookies", [])),
+                "origins_count": len(storage_state.get("origins", [])),
+                "file_path": str(state_file)
+            }
+            
+            if "metadata" not in storage_state:
+                storage_state["metadata"] = {}
+            storage_state["metadata"].update(stats)
+
+            # 写入文件
+            with open(state_file, 'w', encoding='utf-8') as f:
+                json.dump(storage_state, f, indent=2, ensure_ascii=False)
+
+            logger.info(f"认证状态已保存: {state_file} (cookies: {stats['cookies_count']}, origins: {stats['origins_count']})")
+            return str(state_file)
+
+        except Exception as e:
+            logger.error(f"保存认证状态失败: {str(e)}")
+            raise
+
+    def load_auth_state(self, state_name: str) -> Optional[Dict[str, Any]]:
+        """加载认证状态
+
+        Args:
+            state_name: 状态名称
+
+        Returns:
+            Optional[Dict[str, Any]]: 认证状态数据，如果不存在则返回None
+        """
+        try:
+            state_file = self.auth_dir / f"{state_name}.json"
+
+            if not state_file.exists():
+                logger.warning(f"认证状态文件不存在: {state_file}")
+                return None
+
+            with open(state_file, 'r', encoding='utf-8') as f:
+                storage_state = json.load(f)
+
+            logger.info(f"认证状态已加载: {state_file}")
+            return storage_state
+
+        except Exception as e:
+            logger.error(f"加载认证状态失败: {str(e)}")
+            return None
+
+    def has_auth_state(self, state_name: str) -> bool:
+        """检查认证状态是否存在
+
+        Args:
+            state_name: 状态名称
+
+        Returns:
+            bool: 是否存在
+        """
+        state_file = self.auth_dir / f"{state_name}.json"
+        return state_file.exists()
+
+    def delete_auth_state(self, state_name: str) -> bool:
+        """删除认证状态
+
+        Args:
+            state_name: 状态名称
+
+        Returns:
+            bool: 删除是否成功
+        """
+        try:
+            state_file = self.auth_dir / f"{state_name}.json"
+
+            if state_file.exists():
+                state_file.unlink()
+                logger.info(f"认证状态已删除: {state_file}")
+                return True
+            else:
+                logger.warning(f"认证状态文件不存在: {state_file}")
+                return False
+
+        except Exception as e:
+            logger.error(f"删除认证状态失败: {str(e)}")
+            return False
+
+    def list_auth_states(self) -> Dict[str, Dict[str, Any]]:
+        """列出所有认证状态
+
+        Returns:
+            Dict[str, Dict[str, Any]]: 状态名称到元数据的映射
+        """
+        states = {}
+
+        try:
+            for state_file in self.auth_dir.glob("*.json"):
+                state_name = state_file.stem
+
+                try:
+                    with open(state_file, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+
+                    metadata = data.get("metadata", {})
+                    metadata["file_path"] = str(state_file)
+                    metadata["file_size"] = state_file.stat().st_size
+
+                    states[state_name] = metadata
+
+                except Exception as e:
+                    logger.warning(f"无法读取状态文件 {state_file}: {str(e)}")
+
+        except Exception as e:
+            logger.error(f"列出认证状态失败: {str(e)}")
+
+        return states
+
+    def cleanup_expired_states(self, max_age_days: int = 30):
+        """清理过期的认证状态
+
+        Args:
+            max_age_days: 最大保存天数
+        """
+        import time
+
+        try:
+            current_time = time.time()
+            cutoff_time = current_time - (max_age_days * 24 * 60 * 60)
+
+            deleted_count = 0
+            for state_file in self.auth_dir.glob("*.json"):
+                file_mtime = state_file.stat().st_mtime
+
+                if file_mtime < cutoff_time:
+                    state_file.unlink()
+                    deleted_count += 1
+                    logger.info(f"已删除过期认证状态: {state_file}")
+
+            if deleted_count > 0:
+                logger.info(f"清理完成，删除了 {deleted_count} 个过期认证状态")
+            else:
+                logger.info("没有过期的认证状态需要清理")
+
+        except Exception as e:
+            logger.error(f"清理过期认证状态失败: {str(e)}")
+
+    def _get_timestamp(self) -> str:
+        """获取当前时间戳"""
+        import datetime
+        return datetime.datetime.now().isoformat()
+
+
+# 全局认证管理器实例
+auth_manager = AuthManager()

pytest_dsl_ui/core/browser_manager.py

@@ -0,0 +1,261 @@
+"""浏览器管理器
+
+负责管理Playwright浏览器实例的生命周期，包括启动、关闭和配置。
+支持多浏览器、多页面的管理。
+"""
+
+import logging
+from typing import Dict, Optional
+from playwright.sync_api import (
+    sync_playwright, Browser, BrowserContext, Page, Playwright
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BrowserManager:
+    """浏览器管理器
+
+    管理Playwright浏览器实例，支持多浏览器类型和多页面。
+    """
+
+    def __init__(self):
+        """初始化浏览器管理器"""
+        self.playwright: Optional[Playwright] = None
+        self.browsers: Dict[str, Browser] = {}
+        self.contexts: Dict[str, BrowserContext] = {}
+        self.pages: Dict[str, Page] = {}
+        self.current_browser: Optional[str] = None
+        self.current_context: Optional[str] = None
+        self.current_page: Optional[str] = None
+
+    def _ensure_playwright(self):
+        """确保Playwright实例已启动"""
+        if self.playwright is None:
+            self.playwright = sync_playwright().start()
+
+    def launch_browser(self, browser_type: str = "chromium", **config) -> str:
+        """启动浏览器
+
+        Args:
+            browser_type: 浏览器类型 (chromium, firefox, webkit)
+            **config: 浏览器启动配置
+
+        Returns:
+            str: 浏览器ID
+        """
+        self._ensure_playwright()
+
+        # 获取浏览器类型
+        if browser_type.lower() == "chromium":
+            browser_launcher = self.playwright.chromium
+        elif browser_type.lower() == "firefox":
+            browser_launcher = self.playwright.firefox
+        elif browser_type.lower() == "webkit":
+            browser_launcher = self.playwright.webkit
+        else:
+            raise ValueError(f"不支持的浏览器类型: {browser_type}")
+
+        # 处理配置参数
+        launch_config = {
+            "headless": config.get("headless", True),
+            "slow_mo": config.get("slow_mo", 0),
+        }
+
+        # 添加启动参数
+        if "args" in config:
+            launch_config["args"] = config["args"]
+
+        # 添加可执行文件路径
+        if "executable_path" in config:
+            launch_config["executable_path"] = config["executable_path"]
+
+        # 启动浏览器
+        browser = browser_launcher.launch(**launch_config)
+
+        # 生成浏览器ID
+        browser_id = f"{browser_type}_{len(self.browsers)}"
+        self.browsers[browser_id] = browser
+        self.current_browser = browser_id
+
+        logger.info(f"已启动浏览器: {browser_id}")
+        return browser_id
+
+    def create_context(self, browser_id: Optional[str] = None, **config) -> str:
+        """创建浏览器上下文
+
+        Args:
+            browser_id: 浏览器ID，如果为None则使用当前浏览器
+            **config: 上下文配置，支持storage_state参数加载认证状态
+
+        Returns:
+            str: 上下文ID
+        """
+        if browser_id is None:
+            browser_id = self.current_browser
+
+        if browser_id is None:
+            raise ValueError("没有可用的浏览器实例")
+
+        if browser_id not in self.browsers:
+            raise ValueError(f"浏览器 {browser_id} 不存在")
+
+        browser = self.browsers[browser_id]
+
+        # 处理配置参数
+        context_config = {}
+
+        # 视口配置
+        if "viewport" in config:
+            context_config["viewport"] = config["viewport"]
+        elif "width" in config and "height" in config:
+            context_config["viewport"] = {
+                "width": config["width"],
+                "height": config["height"]
+            }
+
+        # 用户代理
+        if "user_agent" in config:
+            context_config["user_agent"] = config["user_agent"]
+
+        # 地理位置
+        if "geolocation" in config:
+            context_config["geolocation"] = config["geolocation"]
+
+        # 权限
+        if "permissions" in config:
+            context_config["permissions"] = config["permissions"]
+
+        # SSL证书忽略配置
+        ignore_https_errors = config.get("ignore_https_errors", False)
+        if ignore_https_errors:
+            context_config["ignore_https_errors"] = True
+
+        # 认证状态配置
+        if "storage_state" in config:
+            context_config["storage_state"] = config["storage_state"]
+            logger.info("将使用认证状态创建浏览器上下文")
+
+        context = browser.new_context(**context_config)
+
+        # 生成上下文ID
+        context_id = f"{browser_id}_ctx_{len(self.contexts)}"
+        self.contexts[context_id] = context
+        self.current_context = context_id
+
+        # 标记上下文是否支持HTTPS证书错误忽略
+        if context_config.get('ignore_https_errors', False):
+            setattr(context, '_ignore_https_errors', True)
+
+        logger.info(f"已创建浏览器上下文: {context_id}")
+        return context_id
+
+    def create_page(self, context_id: Optional[str] = None) -> str:
+        """创建页面
+
+        Args:
+            context_id: 上下文ID，如果为None则使用当前上下文
+
+        Returns:
+            str: 页面ID
+        """
+        if context_id is None:
+            context_id = self.current_context
+
+        if context_id is None:
+            raise ValueError("没有可用的浏览器上下文")
+
+        if context_id not in self.contexts:
+            raise ValueError(f"浏览器上下文 {context_id} 不存在")
+
+        context = self.contexts[context_id]
+        page = context.new_page()
+
+        # 生成页面ID
+        page_id = f"{context_id}_page_{len(self.pages)}"
+        self.pages[page_id] = page
+        self.current_page = page_id
+
+        logger.info(f"已创建页面: {page_id}")
+        return page_id
+
+    def get_current_page(self) -> Page:
+        """获取当前页面实例"""
+        if self.current_page is None or self.current_page not in self.pages:
+            raise ValueError("没有可用的页面实例")
+        return self.pages[self.current_page]
+
+    def get_page(self, page_id: str) -> Page:
+        """获取指定页面实例"""
+        if page_id not in self.pages:
+            raise ValueError(f"页面 {page_id} 不存在")
+        return self.pages[page_id]
+
+    def switch_page(self, page_id: str):
+        """切换到指定页面"""
+        if page_id not in self.pages:
+            raise ValueError(f"页面 {page_id} 不存在")
+        self.current_page = page_id
+        logger.info(f"已切换到页面: {page_id}")
+
+    def close_browser(self, browser_id: Optional[str] = None):
+        """关闭浏览器
+
+        Args:
+            browser_id: 浏览器ID，如果为None则关闭当前浏览器
+        """
+        if browser_id is None:
+            browser_id = self.current_browser
+
+        if browser_id is None:
+            logger.warning("没有可关闭的浏览器实例")
+            return
+
+        if browser_id in self.browsers:
+            browser = self.browsers[browser_id]
+            browser.close()
+            del self.browsers[browser_id]
+
+            # 清理相关的上下文和页面
+            contexts_to_remove = [
+                ctx_id for ctx_id in self.contexts.keys() 
+                if ctx_id.startswith(browser_id)
+            ]
+            for ctx_id in contexts_to_remove:
+                del self.contexts[ctx_id]
+
+            pages_to_remove = [
+                page_id for page_id in self.pages.keys() 
+                if page_id.startswith(browser_id)
+            ]
+            for page_id in pages_to_remove:
+                del self.pages[page_id]
+
+            # 更新当前引用
+            if self.current_browser == browser_id:
+                self.current_browser = None
+                self.current_context = None
+                self.current_page = None
+
+            logger.info(f"已关闭浏览器: {browser_id}")
+
+    def close_all(self):
+        """关闭所有浏览器实例"""
+        for browser in self.browsers.values():
+            browser.close()
+
+        if self.playwright:
+            self.playwright.stop()
+
+        self.browsers.clear()
+        self.contexts.clear()
+        self.pages.clear()
+        self.playwright = None
+        self.current_browser = None
+        self.current_context = None
+        self.current_page = None
+        logger.info("已关闭所有浏览器实例")
+
+
+# 全局浏览器管理器实例
+browser_manager = BrowserManager()