kdtest-pw 2.0.0__py3-none-any.whl

kdtest_pw/plugins/plugin_base.py

@@ -0,0 +1,180 @@
+"""插件基类"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Callable, List, Optional
+from playwright.sync_api import Page
+
+from ..reference import MODULEDATA, INFO
+
+
+class PluginBase(ABC):
+    """插件基类
+
+    所有插件必须继承此类并实现必要方法。
+    """
+
+    # 插件元信息
+    name: str = "base_plugin"
+    version: str = "1.0.0"
+    description: str = "Base plugin"
+    author: str = ""
+
+    def __init__(self, page: Page = None):
+        """初始化插件
+
+        Args:
+            page: Playwright Page 实例
+        """
+        self._page = page
+        self._keywords: Dict[str, Callable] = {}
+        self._element_data: Dict[str, Any] = {}
+        self._config: Dict[str, Any] = {}
+        self._initialized = False
+
+    @abstractmethod
+    def setup(self) -> None:
+        """插件初始化
+
+        子类必须实现此方法，用于：
+        - 注册关键字
+        - 加载元素数据
+        - 初始化配置
+        """
+        pass
+
+    def teardown(self) -> None:
+        """插件清理
+
+        子类可选实现，用于清理资源。
+        """
+        pass
+
+    def register_keyword(self, name: str, handler: Callable) -> None:
+        """注册关键字
+
+        Args:
+            name: 关键字名称
+            handler: 处理函数
+        """
+        self._keywords[name] = handler
+        INFO(f"[{self.name}] 注册关键字: {name}")
+
+    def register_keywords(self, keywords: Dict[str, Callable]) -> None:
+        """批量注册关键字
+
+        Args:
+            keywords: 关键字字典
+        """
+        for name, handler in keywords.items():
+            self.register_keyword(name, handler)
+
+    def load_element_data(self, data: Dict[str, Any]) -> None:
+        """加载元素数据
+
+        Args:
+            data: 元素数据字典
+        """
+        self._element_data.update(data)
+        INFO(f"[{self.name}] 加载元素数据: {len(data)} 个模块")
+
+    def load_element_data_from_file(self, file_path: str) -> None:
+        """从文件加载元素数据
+
+        Args:
+            file_path: YAML 文件路径
+        """
+        try:
+            import yaml
+            from pathlib import Path
+
+            path = Path(file_path)
+            if not path.exists():
+                INFO(f"[{self.name}] 元素数据文件不存在: {file_path}", "WARNING")
+                return
+
+            with open(path, 'r', encoding='utf-8') as f:
+                data = yaml.safe_load(f) or {}
+                self.load_element_data(data)
+
+        except ImportError:
+            INFO(f"[{self.name}] PyYAML 未安装，无法加载 YAML 文件", "WARNING")
+        except Exception as e:
+            INFO(f"[{self.name}] 加载元素数据失败: {e}", "ERROR")
+
+    def load_config(self, config: Dict[str, Any]) -> None:
+        """加载配置
+
+        Args:
+            config: 配置字典
+        """
+        self._config.update(config)
+
+    def load_config_from_file(self, file_path: str) -> None:
+        """从 INI 文件加载配置
+
+        Args:
+            file_path: INI 文件路径
+        """
+        try:
+            import configparser
+            from pathlib import Path
+
+            path = Path(file_path)
+            if not path.exists():
+                INFO(f"[{self.name}] 配置文件不存在: {file_path}", "WARNING")
+                return
+
+            config = configparser.ConfigParser()
+            config.read(str(path), encoding='utf-8')
+
+            for section in config.sections():
+                self._config[section] = dict(config.items(section))
+
+            INFO(f"[{self.name}] 加载配置: {list(self._config.keys())}")
+
+        except Exception as e:
+            INFO(f"[{self.name}] 加载配置失败: {e}", "ERROR")
+
+    @property
+    def keywords(self) -> Dict[str, Callable]:
+        """获取所有关键字"""
+        return self._keywords.copy()
+
+    @property
+    def element_data(self) -> Dict[str, Any]:
+        """获取元素数据"""
+        return self._element_data.copy()
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        """获取配置"""
+        return self._config.copy()
+
+    @property
+    def page(self) -> Optional[Page]:
+        """获取 Page 实例"""
+        return self._page
+
+    def set_page(self, page: Page) -> None:
+        """设置 Page 实例
+
+        Args:
+            page: Playwright Page 实例
+        """
+        self._page = page
+
+    def initialize(self) -> None:
+        """初始化插件（内部调用）"""
+        if not self._initialized:
+            self.setup()
+            self._initialized = True
+
+            # 存储到全局
+            MODULEDATA[self.name] = {
+                'keywords': self._keywords,
+                'element_data': self._element_data,
+                'config': self._config,
+            }
+
+    def __repr__(self) -> str:
+        return f"<Plugin {self.name} v{self.version}>"

kdtest_pw/plugins/plugin_loader.py

@@ -0,0 +1,260 @@
+"""动态插件加载器"""
+
+import importlib
+import importlib.util
+import sys
+from typing import Dict, List, Optional, Type
+from pathlib import Path
+
+from playwright.sync_api import Page
+
+from .plugin_base import PluginBase
+from ..reference import MODULEDATA, INFO
+
+
+class PluginLoader:
+    """动态插件加载器
+
+    从指定目录或模块加载插件。
+    """
+
+    def __init__(self, page: Page = None):
+        """初始化加载器
+
+        Args:
+            page: Playwright Page 实例
+        """
+        self._page = page
+        self._plugins: Dict[str, PluginBase] = {}
+        self._plugin_paths: List[Path] = []
+
+    def add_plugin_path(self, path: str) -> None:
+        """添加插件搜索路径
+
+        Args:
+            path: 插件目录路径
+        """
+        plugin_path = Path(path)
+        if plugin_path.exists() and plugin_path.is_dir():
+            self._plugin_paths.append(plugin_path)
+            INFO(f"添加插件路径: {plugin_path}")
+
+    def load_from_path(self, path: str) -> Optional[PluginBase]:
+        """从路径加载单个插件
+
+        Args:
+            path: 插件目录或模块路径
+
+        Returns:
+            PluginBase: 加载的插件实例
+        """
+        plugin_path = Path(path)
+
+        if plugin_path.is_dir():
+            # 目录形式的插件
+            return self._load_from_directory(plugin_path)
+        elif plugin_path.is_file() and plugin_path.suffix == '.py':
+            # 单文件插件
+            return self._load_from_file(plugin_path)
+
+        return None
+
+    def _load_from_directory(self, directory: Path) -> Optional[PluginBase]:
+        """从目录加载插件
+
+        目录结构:
+        plugin_name/
+        ├── __init__.py
+        ├── plugin_name_plugin.py  (包含插件类)
+        ├── my.ini                 (可选配置)
+        └── elementData/
+            └── elementData.yaml   (可选元素数据)
+
+        Args:
+            directory: 插件目录
+
+        Returns:
+            PluginBase: 插件实例
+        """
+        plugin_name = directory.name
+
+        # 查找插件主文件
+        plugin_file = directory / f"{plugin_name}_plugin.py"
+        if not plugin_file.exists():
+            # 尝试其他命名
+            plugin_files = list(directory.glob("*_plugin.py"))
+            if plugin_files:
+                plugin_file = plugin_files[0]
+            else:
+                INFO(f"未找到插件主文件: {directory}", "WARNING")
+                return None
+
+        # 加载模块
+        spec = importlib.util.spec_from_file_location(plugin_name, plugin_file)
+        if spec is None or spec.loader is None:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[plugin_name] = module
+        spec.loader.exec_module(module)
+
+        # 查找插件类
+        plugin_class = self._find_plugin_class(module)
+        if not plugin_class:
+            INFO(f"未找到 PluginBase 子类: {plugin_file}", "WARNING")
+            return None
+
+        # 创建实例
+        plugin = plugin_class(self._page)
+
+        # 加载配置
+        config_file = directory / "my.ini"
+        if config_file.exists():
+            plugin.load_config_from_file(str(config_file))
+
+        # 加载元素数据
+        element_data_file = directory / "elementData" / "elementData.yaml"
+        if element_data_file.exists():
+            plugin.load_element_data_from_file(str(element_data_file))
+
+        # 初始化
+        plugin.initialize()
+
+        self._plugins[plugin.name] = plugin
+        INFO(f"加载插件: {plugin}")
+
+        return plugin
+
+    def _load_from_file(self, file_path: Path) -> Optional[PluginBase]:
+        """从单文件加载插件
+
+        Args:
+            file_path: 插件文件路径
+
+        Returns:
+            PluginBase: 插件实例
+        """
+        plugin_name = file_path.stem
+
+        spec = importlib.util.spec_from_file_location(plugin_name, file_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[plugin_name] = module
+        spec.loader.exec_module(module)
+
+        plugin_class = self._find_plugin_class(module)
+        if not plugin_class:
+            INFO(f"未找到 PluginBase 子类: {file_path}", "WARNING")
+            return None
+
+        plugin = plugin_class(self._page)
+        plugin.initialize()
+
+        self._plugins[plugin.name] = plugin
+        INFO(f"加载插件: {plugin}")
+
+        return plugin
+
+    def _find_plugin_class(self, module) -> Optional[Type[PluginBase]]:
+        """在模块中查找 PluginBase 子类
+
+        Args:
+            module: Python 模块
+
+        Returns:
+            PluginBase 子类
+        """
+        for name in dir(module):
+            obj = getattr(module, name)
+            if (
+                isinstance(obj, type) and
+                issubclass(obj, PluginBase) and
+                obj is not PluginBase
+            ):
+                return obj
+        return None
+
+    def load_builtin_plugins(self) -> None:
+        """加载内置插件"""
+        # 加载 Element Plus 插件
+        builtin_path = Path(__file__).parent / "element_plus_plugin"
+        if builtin_path.exists():
+            self.load_from_path(str(builtin_path))
+
+    def discover_plugins(self) -> List[PluginBase]:
+        """从所有插件路径发现并加载插件
+
+        Returns:
+            List[PluginBase]: 加载的插件列表
+        """
+        plugins = []
+
+        for plugin_path in self._plugin_paths:
+            for item in plugin_path.iterdir():
+                if item.is_dir() and not item.name.startswith('_'):
+                    plugin = self._load_from_directory(item)
+                    if plugin:
+                        plugins.append(plugin)
+                elif item.is_file() and item.suffix == '.py' and not item.name.startswith('_'):
+                    plugin = self._load_from_file(item)
+                    if plugin:
+                        plugins.append(plugin)
+
+        return plugins
+
+    def get_plugin(self, name: str) -> Optional[PluginBase]:
+        """获取插件
+
+        Args:
+            name: 插件名称
+
+        Returns:
+            PluginBase: 插件实例
+        """
+        return self._plugins.get(name)
+
+    @property
+    def plugins(self) -> Dict[str, PluginBase]:
+        """获取所有加载的插件"""
+        return self._plugins.copy()
+
+    def get_all_keywords(self) -> Dict[str, callable]:
+        """获取所有插件的关键字
+
+        Returns:
+            Dict[str, Callable]: 关键字字典
+        """
+        keywords = {}
+        for plugin in self._plugins.values():
+            keywords.update(plugin.keywords)
+        return keywords
+
+    def get_all_element_data(self) -> Dict[str, any]:
+        """获取所有插件的元素数据
+
+        Returns:
+            Dict[str, Any]: 元素数据字典
+        """
+        element_data = {}
+        for plugin in self._plugins.values():
+            element_data.update(plugin.element_data)
+        return element_data
+
+    def set_page(self, page: Page) -> None:
+        """设置 Page 实例
+
+        Args:
+            page: Playwright Page 实例
+        """
+        self._page = page
+        for plugin in self._plugins.values():
+            plugin.set_page(page)
+
+    def unload_all(self) -> None:
+        """卸载所有插件"""
+        for plugin in self._plugins.values():
+            plugin.teardown()
+        self._plugins.clear()
+        INFO("已卸载所有插件")

kdtest_pw/product.py

@@ -0,0 +1,5 @@
+"""KDTest-Playwright 版本信息"""
+
+__version__ = "2.0.0"
+__author__ = "KDTest Team"
+__description__ = "KDTest Playwright Edition - 关键字驱动测试框架"

kdtest_pw/reference.py

@@ -0,0 +1,99 @@
+"""全局存储模块
+
+提供全局变量存储，用于在模块间共享数据。
+"""
+
+from typing import Any, Dict, Optional
+
+# 全局存储 - 核心组件引用
+GSTORE: Dict[str, Any] = {
+    'browser': None,      # Browser实例
+    'context': None,      # BrowserContext实例
+    'page': None,         # 当前Page实例
+    'keyWord': None,      # KeyWordTest实例
+}
+
+# 全局系统数据存储
+GSDSTORE: Dict[str, Any] = {
+    'START': {},          # 启动参数
+    'WORKPATH': {},       # 工作路径
+}
+
+# 模块数据存储 - 插件数据
+MODULEDATA: Dict[str, Any] = {}
+
+# 私有数据存储
+PRIVATEDATA: Dict[str, Any] = {
+    'PAGES': [],          # 多页面列表
+    'ELEVALUE': {},       # 元素值缓存
+    'CURRENT_CASE': None, # 当前用例名称
+}
+
+# 用例统计数据
+CASESDATA: Dict[str, int] = {
+    'total': 0,
+    'passed': 0,
+    'failed': 0,
+    'skipped': 0,
+}
+
+
+def INFO(message: str, level: str = "INFO") -> None:
+    """统一日志输出
+
+    Args:
+        message: 日志消息
+        level: 日志级别 (INFO, WARNING, ERROR, DEBUG)
+    """
+    print(f"[{level}] {message}")
+
+
+def get_global(key: str, default: Any = None) -> Any:
+    """获取全局存储的值
+
+    Args:
+        key: 键名
+        default: 默认值
+
+    Returns:
+        存储的值或默认值
+    """
+    return GSTORE.get(key, default)
+
+
+def set_global(key: str, value: Any) -> None:
+    """设置全局存储的值
+
+    Args:
+        key: 键名
+        value: 值
+    """
+    GSTORE[key] = value
+
+
+def get_element_value(key: str, default: Any = None) -> Any:
+    """获取缓存的元素值
+
+    Args:
+        key: 键名
+        default: 默认值
+
+    Returns:
+        缓存的元素值或默认值
+    """
+    return PRIVATEDATA['ELEVALUE'].get(key, default)
+
+
+def set_element_value(key: str, value: Any) -> None:
+    """设置元素值缓存
+
+    Args:
+        key: 键名
+        value: 值
+    """
+    PRIVATEDATA['ELEVALUE'][key] = value
+
+
+def clear_element_values() -> None:
+    """清除所有元素值缓存"""
+    PRIVATEDATA['ELEVALUE'].clear()

kdtest_pw/utils/__init__.py

@@ -0,0 +1,13 @@
+"""工具模块"""
+
+from .decorator import retry, timeout, catch_exception
+from .built_in_function import BuiltInFunction
+from .public_script import PublicScript
+
+__all__ = [
+    'retry',
+    'timeout',
+    'catch_exception',
+    'BuiltInFunction',
+    'PublicScript',
+]