pytest-dsl 0.15.3__py3-none-any.whl → 0.15.4__py3-none-any.whl

pytest_dsl/core/remote_server_registry.py

@@ -0,0 +1,333 @@
+"""
+远程服务器注册模块
+
+提供独立的远程服务器注册功能，方便其他系统集成pytest-dsl时使用自己的变量系统。
+这个模块不依赖于YAML配置，完全通过编程方式进行服务器注册。
+"""
+
+from typing import Dict, List, Optional, Any, Callable
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RemoteServerRegistry:
+    """远程服务器注册器
+
+    提供灵活的API用于注册和管理远程关键字服务器，
+    支持自定义变量获取方式，方便第三方系统集成。
+    """
+
+    def __init__(self):
+        self._variable_providers = []  # 变量提供者列表
+        self._server_configs = []      # 服务器配置列表
+        self._connection_callbacks = []  # 连接成功后的回调
+
+    def add_variable_provider(self, provider: Callable[[], Dict[str, Any]]):
+        """添加变量提供者
+
+        变量提供者是一个无参数的可调用对象，返回字典形式的变量。
+        这允许第三方系统提供自己的变量获取逻辑。
+
+        Args:
+            provider: 返回变量字典的可调用对象
+
+        Examples:
+            >>> def my_vars():
+            ...     return {'api_key': 'secret', 'env': 'prod'}
+            >>> registry.add_variable_provider(my_vars)
+        """
+        if callable(provider):
+            self._variable_providers.append(provider)
+        else:
+            raise ValueError("变量提供者必须是可调用对象")
+
+    def add_connection_callback(self, callback: Callable[[str, bool], None]):
+        """添加连接回调
+
+        连接回调会在每次连接远程服务器后被调用，
+        无论连接成功还是失败。
+
+        Args:
+            callback: 接受(alias, success)参数的回调函数
+        """
+        if callable(callback):
+            self._connection_callbacks.append(callback)
+        else:
+            raise ValueError("连接回调必须是可调用对象")
+
+    def register_server(self,
+                        url: str,
+                        alias: str,
+                        api_key: Optional[str] = None,
+                        sync_global_vars: bool = True,
+                        sync_custom_vars: bool = True,
+                        exclude_patterns: Optional[List[str]] = None) -> bool:
+        """注册单个远程服务器
+
+        Args:
+            url: 服务器URL
+            alias: 服务器别名
+            api_key: API密钥
+            sync_global_vars: 是否同步全局变量
+            sync_custom_vars: 是否同步自定义变量（通过变量提供者）
+            exclude_patterns: 要排除的变量名模式列表
+
+        Returns:
+            bool: 是否连接成功
+        """
+        # 构建同步配置
+        sync_config = {
+            'sync_global_vars': sync_global_vars,
+            'sync_yaml_vars': False,  # 不使用YAML变量
+            'sync_custom_vars': sync_custom_vars,
+            'exclude_patterns': exclude_patterns or ['password', 'secret', 'token']
+        }
+
+        # 收集要同步的变量
+        variables_to_sync = {}
+
+        if sync_custom_vars:
+            variables_to_sync.update(self._collect_custom_variables())
+
+        # 尝试连接
+        success = self._connect_to_server(
+            url, alias, api_key, sync_config, variables_to_sync)
+
+        # 调用连接回调
+        for callback in self._connection_callbacks:
+            try:
+                callback(alias, success)
+            except Exception as e:
+                logger.warning(f"连接回调执行失败: {e}")
+
+        if success:
+            # 保存配置以便后续使用
+            self._server_configs.append({
+                'url': url,
+                'alias': alias,
+                'api_key': api_key,
+                'sync_config': sync_config
+            })
+
+        return success
+
+    def register_servers_from_config(self, servers: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+        """从配置列表批量注册服务器
+
+        Args:
+            servers: 服务器配置列表，每个配置包含url、alias等字段
+
+        Returns:
+            dict: 注册结果，键为alias，值为结果详情字典
+
+        Examples:
+            >>> servers = [
+            ...     {'url': 'http://server1:8270', 'alias': 'server1'},
+            ...     {'url': 'http://server2:8270', 'alias': 'server2', 'api_key': 'secret'}
+            ... ]
+            >>> results = registry.register_servers_from_config(servers)
+        """
+        results = {}
+
+        for server_config in servers:
+            if not isinstance(server_config, dict):
+                continue
+
+            url = server_config.get('url')
+            alias = server_config.get('alias')
+
+            if not url or not alias:
+                logger.warning(f"服务器配置缺少必要字段: {server_config}")
+                results[alias or 'unknown'] = {
+                    'success': False,
+                    'url': url or 'unknown',
+                    'alias': alias or 'unknown',
+                    'error': '缺少必要字段'
+                }
+                continue
+
+            api_key = server_config.get('api_key')
+            sync_global_vars = server_config.get('sync_global_vars', True)
+            sync_custom_vars = server_config.get('sync_custom_vars', True)
+            exclude_patterns = server_config.get('exclude_patterns')
+
+            success = self.register_server(
+                url=url,
+                alias=alias,
+                api_key=api_key,
+                sync_global_vars=sync_global_vars,
+                sync_custom_vars=sync_custom_vars,
+                exclude_patterns=exclude_patterns
+            )
+
+            results[alias] = {
+                'success': success,
+                'url': url,
+                'alias': alias
+            }
+
+        return results
+
+    def _collect_custom_variables(self) -> Dict[str, Any]:
+        """收集自定义变量"""
+        variables = {}
+
+        for provider in self._variable_providers:
+            try:
+                provider_vars = provider()
+                if isinstance(provider_vars, dict):
+                    variables.update(provider_vars)
+                else:
+                    logger.warning(f"变量提供者返回了非字典类型: {type(provider_vars)}")
+            except Exception as e:
+                logger.warning(f"变量提供者执行失败: {e}")
+
+        return variables
+
+    def _connect_to_server(self,
+                           url: str,
+                           alias: str,
+                           api_key: Optional[str],
+                           sync_config: Dict[str, Any],
+                           variables: Dict[str, Any]) -> bool:
+        """连接到远程服务器"""
+        try:
+            # 导入远程关键字管理器
+            from pytest_dsl.remote import remote_keyword_manager
+
+            # 创建扩展的同步配置
+            extended_sync_config = sync_config.copy()
+            extended_sync_config['custom_variables'] = variables
+
+            # 注册服务器
+            success = remote_keyword_manager.register_remote_server(
+                url=url,
+                alias=alias,
+                api_key=api_key,
+                sync_config=extended_sync_config
+            )
+
+            if success:
+                logger.info(f"成功连接到远程服务器: {alias} ({url})")
+            else:
+                logger.error(f"连接远程服务器失败: {alias} ({url})")
+
+            return success
+
+        except ImportError:
+            logger.error("远程功能不可用，请检查依赖安装")
+            return False
+        except Exception as e:
+            logger.error(f"连接远程服务器时发生错误: {e}")
+            return False
+
+    def get_registered_servers(self) -> List[Dict[str, Any]]:
+        """获取已注册的服务器列表"""
+        return self._server_configs.copy()
+
+    def clear_variable_providers(self):
+        """清空所有变量提供者"""
+        self._variable_providers.clear()
+
+    def clear_connection_callbacks(self):
+        """清空所有连接回调"""
+        self._connection_callbacks.clear()
+
+
+# 创建全局注册器实例
+remote_server_registry = RemoteServerRegistry()
+
+
+# 便捷函数
+def register_remote_server_with_variables(url: str,
+                                          alias: str,
+                                          variables: Dict[str, Any],
+                                          api_key: Optional[str] = None) -> bool:
+    """使用指定变量注册远程服务器的便捷函数
+
+    Args:
+        url: 服务器URL
+        alias: 服务器别名
+        variables: 要同步的变量字典
+        api_key: API密钥
+
+    Returns:
+        bool: 是否连接成功
+    """
+    # 创建临时变量提供者
+    def temp_provider():
+        return variables
+
+    # 临时添加变量提供者
+    original_providers = remote_server_registry._variable_providers.copy()
+    remote_server_registry._variable_providers = [temp_provider]
+
+    try:
+        return remote_server_registry.register_server(url, alias, api_key)
+    finally:
+        # 恢复原来的变量提供者
+        remote_server_registry._variable_providers = original_providers
+
+
+def create_database_variable_provider(connection_string: str):
+    """创建数据库变量提供者示例
+
+    这是一个示例函数，展示如何创建从数据库获取变量的提供者。
+    实际使用时需要根据具体的数据库类型进行调整。
+
+    Args:
+        connection_string: 数据库连接字符串
+
+    Returns:
+        callable: 变量提供者函数
+    """
+    def database_provider():
+        # 这里是示例代码，实际需要根据数据库类型实现
+        # import sqlite3
+        # conn = sqlite3.connect(connection_string)
+        # cursor = conn.cursor()
+        # cursor.execute("SELECT key, value FROM variables")
+        # variables = dict(cursor.fetchall())
+        # conn.close()
+        # return variables
+
+        return {
+            'db_host': 'localhost',
+            'db_port': '5432',
+            'db_name': 'test_db'
+        }
+
+    return database_provider
+
+
+def create_config_file_variable_provider(config_file_path: str):
+    """创建配置文件变量提供者
+
+    从JSON或其他配置文件读取变量。
+
+    Args:
+        config_file_path: 配置文件路径
+
+    Returns:
+        callable: 变量提供者函数
+    """
+    import json
+    import os
+
+    def config_file_provider():
+        if not os.path.exists(config_file_path):
+            return {}
+
+        try:
+            with open(config_file_path, 'r', encoding='utf-8') as f:
+                if config_file_path.endswith('.json'):
+                    return json.load(f)
+                else:
+                    # 可以扩展支持其他格式
+                    return {}
+        except Exception as e:
+            logger.warning(f"读取配置文件失败: {e}")
+            return {}
+
+    return config_file_provider

pytest_dsl/core/utils.py

@@ -69,7 +69,8 @@ def _legacy_replace_variables_in_string(value: str) -> str:
                     break
 
             # 替换变量引用
-            value = value[:match.start()] + str(var_value) + value[match.end():]
+            value = value[:match.start()] + str(var_value) + \
+                value[match.end():]
 
     # 再处理基本引用
     matches = list(re.finditer(basic_pattern, value))
@@ -77,7 +78,8 @@ def _legacy_replace_variables_in_string(value: str) -> str:
         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():]
+            value = value[:match.start()] + str(var_value) + \
+                value[match.end():]
 
     return value
 
@@ -102,37 +104,42 @@ def replace_variables_in_dict(data: Union[Dict, List, str]) -> Union[Dict, List,
 
 
 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
+    """检查变量是否存在于上下文中
 
+    检查顺序：
+    1. 测试上下文
+    2. 全局上下文（包含YAML变量）
+    """
     # 检查测试上下文
-    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
-
-    # 再检查全局上下文
+    try:
+        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
+    except ImportError:
+        pass
+
+    # 检查全局上下文（包含YAML变量的统一访问）
     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)
-
-    # 再从全局上下文获取
+    获取顺序：
+    1. 测试上下文
+    2. 全局上下文（包含YAML变量）
+    """
+    # 先从测试上下文获取
+    try:
+        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)
+    except ImportError:
+        pass
+
+    # 再从全局上下文获取（包含对YAML变量的统一访问）
     if global_context.has_variable(var_name):
         return global_context.get_variable(var_name)
 
@@ -163,4 +170,4 @@ def deep_merge(base: Dict, override: Dict) -> Dict:
             # 覆盖或添加值
             result[key] = value
 
-    return result
+    return result

pytest_dsl/core/variable_providers.py

@@ -0,0 +1,202 @@
+"""变量提供者模块
+
+定义了变量提供者的接口和具体实现，用于将不同来源的变量注入到TestContext中。
+这样可以实现解耦，让关键字只需要通过context获取变量，而不需要直接依赖特定的变量源。
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Dict
+
+
+class VariableProvider(ABC):
+    """变量提供者接口
+
+    所有的变量提供者都需要实现这个接口，以便可以注册到TestContext中。
+    """
+
+    @abstractmethod
+    def get_variable(self, key: str) -> Optional[Any]:
+        """获取变量值
+
+        Args:
+            key: 变量键
+
+        Returns:
+            变量值，如果不存在返回None
+        """
+        pass
+
+    @abstractmethod
+    def has_variable(self, key: str) -> bool:
+        """检查变量是否存在
+
+        Args:
+            key: 变量键
+
+        Returns:
+            True如果变量存在，否则False
+        """
+        pass
+
+    def get_all_variables(self) -> Dict[str, Any]:
+        """获取所有变量（可选实现）
+
+        Returns:
+            包含所有变量的字典
+        """
+        return {}
+
+
+class YAMLVariableProvider(VariableProvider):
+    """YAML变量提供者
+
+    将yaml_vars包装成变量提供者，使其可以注入到TestContext中。
+    """
+
+    def __init__(self):
+        # 延迟导入，避免循环依赖
+        from pytest_dsl.core.yaml_vars import yaml_vars
+        self.yaml_vars = yaml_vars
+
+    def get_variable(self, key: str) -> Optional[Any]:
+        """从YAML变量源获取变量值"""
+        return self.yaml_vars.get_variable(key)
+
+    def has_variable(self, key: str) -> bool:
+        """检查YAML变量源中是否存在变量"""
+        return self.yaml_vars.has_variable(key)
+
+    def get_all_variables(self) -> Dict[str, Any]:
+        """获取所有YAML变量"""
+        return self.yaml_vars.get_all_variables()
+
+
+class GlobalContextVariableProvider(VariableProvider):
+    """全局上下文变量提供者
+
+    将global_context包装成变量提供者，但需要避免和YAML变量重复。
+    """
+
+    def __init__(self):
+        # 延迟导入，避免循环依赖
+        from pytest_dsl.core.global_context import global_context
+        self.global_context = global_context
+
+    def get_variable(self, key: str) -> Optional[Any]:
+        """从全局上下文获取变量值"""
+        # 注意：global_context的get_variable方法内部也会调用yaml_vars
+        # 为了避免重复，这里直接访问存储的变量
+        try:
+            # 直接从全局变量存储中获取，跳过YAML变量
+            from filelock import FileLock
+            with FileLock(self.global_context._lock_file):
+                variables = self.global_context._load_variables()
+                return variables.get(key)
+        except Exception:
+            return None
+
+    def has_variable(self, key: str) -> bool:
+        """检查全局上下文中是否存在变量"""
+        try:
+            from filelock import FileLock
+            with FileLock(self.global_context._lock_file):
+                variables = self.global_context._load_variables()
+                return key in variables
+        except Exception:
+            return False
+
+    def get_all_variables(self) -> Dict[str, Any]:
+        """获取所有全局变量"""
+        try:
+            from filelock import FileLock
+            with FileLock(self.global_context._lock_file):
+                return self.global_context._load_variables()
+        except Exception:
+            return {}
+
+
+class CompositeVariableProvider(VariableProvider):
+    """组合变量提供者
+
+    可以将多个变量提供者组合在一起，按优先级顺序查找变量。
+    """
+
+    def __init__(self, providers: list = None):
+        """初始化组合变量提供者
+
+        Args:
+            providers: 变量提供者列表，按优先级排序（索引越小优先级越高）
+        """
+        self.providers = providers or []
+
+    def add_provider(self, provider: VariableProvider):
+        """添加变量提供者"""
+        if provider not in self.providers:
+            self.providers.append(provider)
+
+    def remove_provider(self, provider: VariableProvider):
+        """移除变量提供者"""
+        if provider in self.providers:
+            self.providers.remove(provider)
+
+    def get_variable(self, key: str) -> Optional[Any]:
+        """按优先级顺序从提供者中获取变量"""
+        for provider in self.providers:
+            try:
+                value = provider.get_variable(key)
+                if value is not None:
+                    return value
+            except Exception:
+                continue
+        return None
+
+    def has_variable(self, key: str) -> bool:
+        """检查是否有任何提供者包含该变量"""
+        for provider in self.providers:
+            try:
+                if provider.has_variable(key):
+                    return True
+            except Exception:
+                continue
+        return False
+
+    def get_all_variables(self) -> Dict[str, Any]:
+        """获取所有变量，优先级高的覆盖优先级低的"""
+        all_vars = {}
+
+        # 从后往前遍历，让优先级高的覆盖优先级低的
+        for provider in reversed(self.providers):
+            try:
+                vars_dict = provider.get_all_variables()
+                all_vars.update(vars_dict)
+            except Exception:
+                continue
+
+        return all_vars
+
+
+# 创建默认的变量提供者实例
+def create_default_variable_providers() -> list:
+    """创建默认的变量提供者列表
+
+    按优先级排序：YAML变量 > 全局上下文变量
+
+    Returns:
+        变量提供者列表
+    """
+    providers = [
+        YAMLVariableProvider(),
+        GlobalContextVariableProvider()
+    ]
+    return providers
+
+
+def setup_context_with_default_providers(context):
+    """为TestContext设置默认的变量提供者
+
+    Args:
+        context: TestContext实例
+    """
+    providers = create_default_variable_providers()
+    for provider in providers:
+        context.register_external_variable_provider(provider)