pytest-dsl 0.1.0__py3-none-any.whl

pytest_dsl/core/plugin_discovery.py

@@ -0,0 +1,187 @@
+"""插件发现模块
+
+该模块提供了下列功能：
+1. 使用entry_points机制发现和加载第三方关键字插件
+2. 扫描本地内置关键字（向后兼容）
+3. 自动扫描并导入用户项目中的keywords目录下的关键字模块
+
+自定义关键字目录结构：
+- 项目根目录/
+  - keywords/                  # 关键字根目录
+    - __init__.py              # 可选，如果要作为包导入
+    - my_keywords.py           # 顶层关键字模块
+    - another_module.py        # 顶层关键字模块
+    - web/                     # 子目录（可选作为子包）
+      - __init__.py            # 可选，如果要作为子包导入
+      - selenium_keywords.py   # 子目录中的关键字模块
+
+每个关键字模块中应使用keyword_manager.register装饰器注册关键字。
+"""
+
+import importlib
+import importlib.util
+import importlib.metadata
+import pkgutil
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+from pytest_dsl.core.keyword_manager import keyword_manager
+
+
+def discover_installed_plugins() -> List[str]:
+    """
+    发现所有已安装的pytest-dsl关键字插件
+    
+    通过entry_points机制查找所有声明了'pytest_dsl.keywords'入口点的包
+    
+    Returns:
+        List[str]: 已安装的插件包名列表
+    """
+    plugins = []
+    try:
+        eps = importlib.metadata.entry_points(group='pytest_dsl.keywords')
+        for ep in eps:
+            plugins.append(ep.module)
+    except Exception as e:
+        print(f"发现插件时出错: {e}")
+    return plugins
+
+
+def load_plugin_keywords(plugin_name: str) -> None:
+    """
+    加载指定插件包中的所有关键字
+    
+    Args:
+        plugin_name: 插件包名
+    """
+    try:
+        # 导入插件包
+        plugin = importlib.import_module(plugin_name)
+        
+        # 如果插件有register_keywords函数，调用它
+        if hasattr(plugin, 'register_keywords') and callable(plugin.register_keywords):
+            plugin.register_keywords(keyword_manager)
+            return
+        
+        # 否则，遍历包中的所有模块
+        if hasattr(plugin, '__path__'):
+            for _, name, is_pkg in pkgutil.iter_modules(plugin.__path__, plugin.__name__ + '.'):
+                if not is_pkg:
+                    try:
+                        module = importlib.import_module(name)
+                        # 模块已导入，关键字装饰器会自动注册
+                    except ImportError as e:
+                        print(f"无法导入模块 {name}: {e}")
+    except ImportError as e:
+        print(f"无法导入插件 {plugin_name}: {e}")
+
+
+def load_all_plugins() -> None:
+    """
+    发现并加载所有已安装的关键字插件
+    """
+    plugins = discover_installed_plugins()
+    for plugin_name in plugins:
+        load_plugin_keywords(plugin_name)
+
+
+def _load_module_from_file(file_path):
+    """
+    从文件路径动态加载Python模块
+    
+    Args:
+        file_path: Python文件路径
+    
+    Returns:
+        加载成功返回True，否则返回False
+    """
+    try:
+        module_name = file_path.stem
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec:
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            print(f"已加载项目关键字模块: {module_name}")
+            return True
+    except Exception as e:
+        print(f"加载项目关键字模块 {file_path.name} 时出错: {e}")
+        return False
+
+
+def scan_local_keywords() -> None:
+    """
+    扫描本地keywords目录中的关键字
+    
+    1. 先尝试导入内置的keywords包（向后兼容）
+    2. 再查找并导入用户项目根目录下的keywords目录中的Python模块
+    """
+    # 1. 尝试导入内置的keywords包
+    try:
+        import keywords
+    except ImportError:
+        print("提示: 未找到内置关键字包")
+    
+    # 2. 查找并导入用户项目中的keywords目录
+    try:
+        # 获取当前工作目录，通常是用户项目的根目录
+        project_root = Path(os.getcwd())
+        keywords_dir = project_root / 'keywords'
+        
+        if keywords_dir.exists() and keywords_dir.is_dir():
+            print(f"发现项目关键字目录: {keywords_dir}")
+            
+            # 将keywords目录添加到Python路径中，以便能够导入
+            if str(keywords_dir) not in sys.path:
+                sys.path.insert(0, str(keywords_dir))
+            
+            # 首先尝试作为包导入整个keywords目录
+            if (keywords_dir / '__init__.py').exists():
+                try:
+                    importlib.import_module('keywords')
+                    print("已加载项目keywords包")
+                except ImportError as e:
+                    print(f"导入项目keywords包失败: {e}")
+            
+            # 遍历keywords目录下的所有Python文件（包括子目录）
+            loaded_modules = 0
+            
+            # 先加载顶层目录中的模块
+            for file_path in keywords_dir.glob('*.py'):
+                if file_path.name != '__init__.py':
+                    if _load_module_from_file(file_path):
+                        loaded_modules += 1
+            
+            # 然后遍历子目录
+            for subdir in [d for d in keywords_dir.iterdir() if d.is_dir()]:
+                # 检查子目录是否为Python包
+                init_file = subdir / '__init__.py'
+                if init_file.exists():
+                    # 尝试作为包导入
+                    subdir_name = subdir.name
+                    try:
+                        importlib.import_module(f'keywords.{subdir_name}')
+                        print(f"已加载项目关键字子包: {subdir_name}")
+                        loaded_modules += 1
+                    except ImportError as e:
+                        print(f"导入项目关键字子包 {subdir_name} 失败: {e}")
+                
+                # 无论是否为包，都尝试直接加载其中的Python文件
+                for file_path in subdir.glob('*.py'):
+                    if file_path.name != '__init__.py':
+                        if _load_module_from_file(file_path):
+                            loaded_modules += 1
+            
+            if loaded_modules > 0:
+                print(f"成功从项目中加载了 {loaded_modules} 个关键字模块")
+            else:
+                print("未从项目中加载到任何关键字模块")
+        else:
+            print("提示: 未在项目中找到keywords目录")
+    except Exception as e:
+        print(f"扫描项目关键字时出错: {e}")
+
+
+if __name__ == "__main__":
+    load_all_plugins()

pytest_dsl/core/utils.py

@@ -0,0 +1,146 @@
+"""工具函数模块
+
+该模块提供了各种共享的工具函数。
+"""
+
+import re
+from typing import Dict, Any, Union, List
+
+from pytest_dsl.core.global_context import global_context
+
+
+def replace_variables_in_string(value: str) -> str:
+    """替换字符串中的变量引用，包括嵌套的点号引用
+    
+    Args:
+        value: 包含变量引用的字符串
+        
+    Returns:
+        替换后的字符串
+    """
+    if not isinstance(value, str):
+        return value
+        
+    # 基本变量引用模式: ${variable}
+    basic_pattern = r'\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}'
+    
+    # 嵌套引用模式: ${variable.field.subfield}
+    nested_pattern = r'\$\{([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+)\}'
+    
+    # 先处理嵌套引用
+    matches = list(re.finditer(nested_pattern, value))
+    for match in reversed(matches):
+        var_ref = match.group(1)  # 例如: "api_test_data.user_id"
+        parts = var_ref.split('.')
+        
+        # 获取根变量
+        root_var_name = parts[0]
+        if context_has_variable(root_var_name):
+            root_var = get_variable(root_var_name)
+            
+            # 递归访问嵌套属性
+            var_value = root_var
+            for part in parts[1:]:
+                if isinstance(var_value, dict) and part in var_value:
+                    var_value = var_value[part]
+                else:
+                    # 无法解析的属性路径
+                    var_value = f"${{{var_ref}}}"  # 保持原样
+                    break
+            
+            # 替换变量引用
+            value = value[:match.start()] + str(var_value) + value[match.end():]
+    
+    # 再处理基本引用
+    matches = list(re.finditer(basic_pattern, value))
+    for match in reversed(matches):
+        var_name = match.group(1)
+        if context_has_variable(var_name):
+            var_value = get_variable(var_name)
+            value = value[:match.start()] + str(var_value) + value[match.end():]
+    
+    return value
+
+
+def replace_variables_in_dict(data: Union[Dict, List, str]) -> Union[Dict, List, str]:
+    """递归替换字典中的变量引用
+    
+    Args:
+        data: 包含变量引用的字典、列表或字符串
+        
+    Returns:
+        替换变量后的数据
+    """
+    if isinstance(data, dict):
+        return {k: replace_variables_in_dict(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [replace_variables_in_dict(item) for item in data]
+    elif isinstance(data, str) and '${' in data:
+        return replace_variables_in_string(data)
+    else:
+        return data
+
+
+def context_has_variable(var_name: str) -> bool:
+    """检查变量是否存在于全局上下文"""
+    # 先检查YAML变量
+    from pytest_dsl.core.yaml_vars import yaml_vars
+    if yaml_vars.get_variable(var_name) is not None:
+        return True
+    
+    # 检查测试上下文
+    from pytest_dsl.core.keyword_manager import keyword_manager
+    current_context = getattr(keyword_manager, 'current_context', None)
+    if current_context and current_context.has(var_name):
+        return True
+    
+    # 再检查全局上下文
+    return global_context.has_variable(var_name)
+
+
+def get_variable(var_name: str) -> Any:
+    """获取变量值，先从YAML变量中获取，再从全局上下文获取"""
+    # 先从YAML变量中获取
+    from pytest_dsl.core.yaml_vars import yaml_vars
+    yaml_value = yaml_vars.get_variable(var_name)
+    if yaml_value is not None:
+        return yaml_value
+    
+    # 检查测试上下文
+    from pytest_dsl.core.keyword_manager import keyword_manager
+    current_context = getattr(keyword_manager, 'current_context', None)
+    if current_context and current_context.has(var_name):
+        return current_context.get(var_name)
+    
+    # 再从全局上下文获取
+    if global_context.has_variable(var_name):
+        return global_context.get_variable(var_name)
+    
+    # 如果都没有找到，返回变量引用本身
+    return f"${{{var_name}}}"
+
+
+def deep_merge(base: Dict, override: Dict) -> Dict:
+    """深度合并两个字典
+    
+    Args:
+        base: 基础字典
+        override: 覆盖字典
+        
+    Returns:
+        合并后的字典
+    """
+    result = base.copy()
+    
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            # 递归合并嵌套字典
+            result[key] = deep_merge(result[key], value)
+        elif key in result and isinstance(result[key], list) and isinstance(value, list):
+            # 合并列表
+            result[key] = result[key] + value
+        else:
+            # 覆盖或添加值
+            result[key] = value
+            
+    return result 

pytest_dsl/core/variable_utils.py

@@ -0,0 +1,267 @@
+import re
+import json
+from typing import Any, Dict, List, Union
+from pytest_dsl.core.global_context import global_context
+from pytest_dsl.core.context import TestContext
+from pytest_dsl.core.yaml_vars import yaml_vars
+
+
+class VariableReplacer:
+    """统一的变量替换工具类
+    
+    提供统一的变量替换功能，支持字符串、字典和列表中的变量替换。
+    变量查找优先级：本地变量 > 测试上下文 > YAML变量 > 全局上下文
+    """
+    
+    def __init__(self, local_variables: Dict[str, Any] = None, test_context: TestContext = None):
+        """初始化变量替换器
+        
+        Args:
+            local_variables: 本地变量字典
+            test_context: 测试上下文对象
+        """
+        self.local_variables = local_variables or {}
+        self._test_context = test_context or TestContext()
+        
+    @property
+    def test_context(self) -> TestContext:
+        """获取测试上下文，确保始终使用最新的上下文对象
+        
+        如果上下文对象中包含executor属性，则使用executor的上下文
+        （这确保即使上下文被替换也能获取正确的引用）
+        
+        Returns:
+            测试上下文对象
+        """
+        if hasattr(self._test_context, 'executor') and self._test_context.executor is not None:
+            return self._test_context.executor.test_context
+        return self._test_context
+        
+    def get_variable(self, var_name: str) -> Any:
+        """获取变量值，按照优先级查找
+        
+        Args:
+            var_name: 变量名
+            
+        Returns:
+            变量值，如果变量不存在则抛出 KeyError
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        # 从本地变量获取
+        if var_name in self.local_variables:
+            value = self.local_variables[var_name]
+            return self._convert_value(value)
+        
+        # 从测试上下文中获取
+        if self.test_context.has(var_name):
+            value = self.test_context.get(var_name)
+            return self._convert_value(value)
+        
+        # 从YAML变量中获取
+        yaml_value = yaml_vars.get_variable(var_name)
+        if yaml_value is not None:
+            return self._convert_value(yaml_value)
+            
+        # 从全局上下文获取
+        if global_context.has_variable(var_name):
+            value = global_context.get_variable(var_name)
+            return self._convert_value(value)
+            
+        # 如果变量不存在，抛出异常
+        raise KeyError(f"变量 '{var_name}' 不存在")
+    
+    def _convert_value(self, value: Any) -> Any:
+        """转换值为正确的类型
+        
+        Args:
+            value: 要转换的值
+            
+        Returns:
+            转换后的值
+        """
+        if isinstance(value, str):
+            # 处理布尔值
+            if value.lower() in ('true', 'false'):
+                return value.lower() == 'true'
+            # 处理数字
+            try:
+                if '.' in value:
+                    return float(value)
+                return int(value)
+            except (ValueError, TypeError):
+                pass
+        return value
+    
+    def replace_in_string(self, value: str) -> str:
+        """替换字符串中的变量引用
+        
+        Args:
+            value: 包含变量引用的字符串
+            
+        Returns:
+            替换后的字符串
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        if not isinstance(value, str) or '${' not in value:
+            return value
+            
+        # 处理变量引用模式: ${variable} 或 ${variable.field.subfield}
+        pattern = r'\$\{([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\}'
+        
+        result = value
+        matches = list(re.finditer(pattern, result))
+        
+        # 从后向前替换，避免位置偏移
+        for match in reversed(matches):
+            var_ref = match.group(1)  # 例如: "api_test_data.user_id" 或 "variable"
+            parts = var_ref.split('.')
+            
+            # 获取根变量
+            root_var_name = parts[0]
+            try:
+                root_var = self.get_variable(root_var_name)
+            except KeyError:
+                raise KeyError(f"变量 '{root_var_name}' 不存在")
+            
+            # 递归访问嵌套属性
+            var_value = root_var
+            for part in parts[1:]:
+                if isinstance(var_value, dict) and part in var_value:
+                    var_value = var_value[part]
+                else:
+                    raise KeyError(f"无法访问属性 '{part}'，变量 '{root_var_name}' 的类型是 {type(var_value).__name__}")
+            
+            # 替换变量引用
+            result = result[:match.start()] + str(var_value) + result[match.end():]
+        
+        return result
+    
+    def replace_in_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """递归替换字典中的变量引用
+        
+        Args:
+            data: 包含变量引用的字典
+            
+        Returns:
+            替换后的字典
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        if not isinstance(data, dict):
+            return data
+            
+        result = {}
+        for key, value in data.items():
+            # 替换键中的变量
+            new_key = self.replace_in_string(key) if isinstance(key, str) else key
+            # 替换值中的变量
+            new_value = self.replace_in_value(value)
+            result[new_key] = new_value
+            
+        return result
+    
+    def replace_in_list(self, data: List[Any]) -> List[Any]:
+        """递归替换列表中的变量引用
+        
+        Args:
+            data: 包含变量引用的列表
+            
+        Returns:
+            替换后的列表
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        if not isinstance(data, list):
+            return data
+            
+        return [self.replace_in_value(item) for item in data]
+    
+    def replace_in_value(self, value: Any) -> Any:
+        """递归替换任意值中的变量引用
+        
+        Args:
+            value: 任意值，可能是字符串、字典、列表等
+            
+        Returns:
+            替换后的值
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        if isinstance(value, str):
+            return self.replace_in_string(value)
+        elif isinstance(value, dict):
+            return self.replace_in_dict(value)
+        elif isinstance(value, list):
+            return self.replace_in_list(value)
+        elif isinstance(value, (int, float, bool, type(None))):
+            return value
+        else:
+            # 对于其他类型，尝试转换为字符串后替换
+            try:
+                str_value = str(value)
+                if '${' in str_value:
+                    replaced = self.replace_in_string(str_value)
+                    # 尝试将替换后的字符串转换回原始类型
+                    if isinstance(value, (int, float)):
+                        return type(value)(replaced)
+                    elif isinstance(value, bool):
+                        return replaced.lower() == 'true'
+                    return replaced
+                return value
+            except:
+                return value
+    
+    def replace_in_json(self, json_str: str) -> str:
+        """替换JSON字符串中的变量引用
+        
+        Args:
+            json_str: 包含变量引用的JSON字符串
+            
+        Returns:
+            替换后的JSON字符串
+            
+        Raises:
+            KeyError: 当变量不存在时
+            json.JSONDecodeError: 当JSON解析失败时
+        """
+        try:
+            # 先解析JSON
+            data = json.loads(json_str)
+            # 替换变量
+            replaced_data = self.replace_in_value(data)
+            # 重新序列化为JSON
+            return json.dumps(replaced_data, ensure_ascii=False)
+        except json.JSONDecodeError:
+            # 如果JSON解析失败，直接作为字符串处理
+            return self.replace_in_string(json_str)
+    
+    def replace_in_yaml(self, yaml_str: str) -> str:
+        """替换YAML字符串中的变量引用
+        
+        Args:
+            yaml_str: 包含变量引用的YAML字符串
+            
+        Returns:
+            替换后的YAML字符串
+            
+        Raises:
+            KeyError: 当变量不存在时
+        """
+        try:
+            import yaml
+            # 先解析YAML
+            data = yaml.safe_load(yaml_str)
+            # 替换变量
+            replaced_data = self.replace_in_value(data)
+            # 重新序列化为YAML
+            return yaml.dump(replaced_data, allow_unicode=True)
+        except:
+            # 如果YAML解析失败，直接作为字符串处理
+            return self.replace_in_string(yaml_str) 

pytest_dsl/core/yaml_loader.py

@@ -0,0 +1,62 @@
+"""YAML变量加载器模块
+
+该模块负责处理YAML变量文件的加载和管理，支持从命令行参数加载单个文件或目录。
+"""
+
+import os
+from pathlib import Path
+from pytest_dsl.core.yaml_vars import yaml_vars
+
+
+def add_yaml_options(parser):
+    """添加YAML变量相关的命令行参数选项
+    
+    Args:
+        parser: pytest命令行参数解析器
+    """
+    group = parser.getgroup('yaml-vars')
+    group.addoption(
+        '--yaml-vars',
+        action='append',
+        default=[],
+        help='YAML变量文件路径，可以指定多个文件 (例如: --yaml-vars vars1.yaml --yaml-vars vars2.yaml)'
+    )
+    group.addoption(
+        '--yaml-vars-dir',
+        action='store',
+        default=None,
+        help='YAML变量文件目录路径，将加载该目录下所有.yaml文件，默认为项目根目录下的config目录'
+    )
+
+
+def load_yaml_variables(config):
+    """加载YAML变量文件
+    
+    从命令行参数指定的文件和目录加载YAML变量。
+    
+    Args:
+        config: pytest配置对象
+    """
+    # 加载单个YAML文件
+    yaml_files = config.getoption('--yaml-vars')
+    if yaml_files:
+        yaml_vars.load_yaml_files(yaml_files)
+        print(f"已加载YAML变量文件: {', '.join(yaml_files)}")
+
+    # 加载目录中的YAML文件
+    yaml_vars_dir = config.getoption('--yaml-vars-dir')
+    if yaml_vars_dir is None:
+        # 默认使用使用者项目根目录下的config目录
+        # 通过pytest的rootdir获取使用者的项目根目录
+        project_root = config.rootdir
+        yaml_vars_dir = str(project_root / 'config')
+        print(f"使用默认YAML变量目录: {yaml_vars_dir}")
+    
+    if Path(yaml_vars_dir).exists():
+        yaml_vars.load_from_directory(yaml_vars_dir)
+        print(f"已加载YAML变量目录: {yaml_vars_dir}")
+        loaded_files = yaml_vars.get_loaded_files()
+        if loaded_files:
+            print(f"目录中加载的文件: {', '.join(loaded_files)}")
+    else:
+        print(f"YAML变量目录不存在: {yaml_vars_dir}")