pytest-dsl 0.15.3__py3-none-any.whl → 0.15.5__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/serialization_utils.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+序列化工具模块
+
+提供统一的XML-RPC序列化检查和转换功能，避免代码重复。
+"""
+
+import datetime
+from typing import Any, Dict, List, Optional
+
+
+class XMLRPCSerializer:
+    """XML-RPC序列化工具类
+    
+    统一处理XML-RPC序列化检查、转换和过滤逻辑，
+    避免在多个类中重复实现相同的序列化代码。
+    """
+    
+    # 敏感信息过滤模式
+    DEFAULT_EXCLUDE_PATTERNS = [
+        'password', 'secret', 'token', 'credential', 'auth', 'private'
+    ]
+    
+    @staticmethod
+    def is_serializable(value: Any) -> bool:
+        """检查值是否可以被XML-RPC序列化
+        
+        XML-RPC支持的类型：
+        - None (需要allow_none=True)
+        - bool, int, float, str, bytes
+        - datetime.datetime
+        - list (元素也必须可序列化)
+        - dict (键必须是字符串，值必须可序列化)
+        
+        Args:
+            value: 要检查的值
+            
+        Returns:
+            bool: 是否可序列化
+        """
+        # 基本类型
+        if value is None:
+            return True
+        if isinstance(value, (bool, int, float, str, bytes)):
+            return True
+        if isinstance(value, datetime.datetime):
+            return True
+        
+        # 严格检查：只允许内置的list和dict类型，不允许自定义类
+        value_type = type(value)
+        
+        # 检查是否为内置list类型（不是子类）
+        if value_type is list:
+            try:
+                for item in value:
+                    if not XMLRPCSerializer.is_serializable(item):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 检查是否为内置tuple类型
+        if value_type is tuple:
+            try:
+                for item in value:
+                    if not XMLRPCSerializer.is_serializable(item):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 检查是否为内置dict类型（不是子类，如DotAccessDict）
+        if value_type is dict:
+            try:
+                for k, v in value.items():
+                    # XML-RPC要求字典的键必须是字符串
+                    if not isinstance(k, str):
+                        return False
+                    if not XMLRPCSerializer.is_serializable(v):
+                        return False
+                return True
+            except Exception:
+                return False
+        
+        # 其他类型都不可序列化
+        return False
+    
+    @staticmethod
+    def convert_to_serializable(value: Any) -> Optional[Any]:
+        """尝试将值转换为XML-RPC可序列化的格式
+        
+        Args:
+            value: 要转换的值
+            
+        Returns:
+            转换后的值，如果无法转换则返回None
+        """
+        # 如果已经可序列化，直接返回
+        if XMLRPCSerializer.is_serializable(value):
+            return value
+        
+        # 尝试转换类字典对象为标准字典
+        if hasattr(value, 'keys') and hasattr(value, 'items'):
+            try:
+                converted_dict = {}
+                for k, v in value.items():
+                    # 键必须是字符串
+                    if not isinstance(k, str):
+                        k = str(k)
+                    
+                    # 递归转换值
+                    converted_value = XMLRPCSerializer.convert_to_serializable(v)
+                    if converted_value is not None or v is None:
+                        converted_dict[k] = converted_value
+                    else:
+                        # 如果无法转换子值，跳过这个键值对
+                        print(f"跳过无法转换的字典项: {k} "
+                              f"(类型: {type(v).__name__})")
+                        continue
+                
+                return converted_dict
+            except Exception as e:
+                print(f"转换类字典对象失败: {e}")
+                return None
+        
+        # 尝试转换类列表对象为标准列表
+        if hasattr(value, '__iter__') and not isinstance(value, (str, bytes)):
+            try:
+                converted_list = []
+                for item in value:
+                    converted_item = XMLRPCSerializer.convert_to_serializable(item)
+                    if converted_item is not None or item is None:
+                        converted_list.append(converted_item)
+                    else:
+                        # 如果无法转换子项，跳过
+                        print(f"跳过无法转换的列表项: "
+                              f"(类型: {type(item).__name__})")
+                        continue
+                
+                return converted_list
+            except Exception as e:
+                print(f"转换类列表对象失败: {e}")
+                return None
+        
+        # 尝试转换为字符串表示
+        try:
+            str_value = str(value)
+            # 避免转换过长的字符串或包含敏感信息的对象
+            if (len(str_value) < 1000 and 
+                not any(pattern in str_value.lower() 
+                       for pattern in XMLRPCSerializer.DEFAULT_EXCLUDE_PATTERNS)):
+                return str_value
+        except Exception:
+            pass
+        
+        # 无法转换
+        return None
+    
+    @staticmethod
+    def filter_variables(variables: Dict[str, Any], 
+                        exclude_patterns: Optional[List[str]] = None) -> Dict[str, Any]:
+        """过滤变量字典，移除敏感变量和不可序列化的变量
+        
+        Args:
+            variables: 原始变量字典
+            exclude_patterns: 排除模式列表，如果为None则使用默认模式
+            
+        Returns:
+            Dict[str, Any]: 过滤后的变量字典
+        """
+        if exclude_patterns is None:
+            exclude_patterns = XMLRPCSerializer.DEFAULT_EXCLUDE_PATTERNS
+        
+        filtered_variables = {}
+        
+        for var_name, var_value in variables.items():
+            # 检查是否需要排除
+            should_exclude = False
+            var_name_lower = var_name.lower()
+            
+            # 检查变量名
+            for pattern in exclude_patterns:
+                if pattern.lower() in var_name_lower:
+                    should_exclude = True
+                    break
+            
+            # 如果值是字符串，也检查是否包含敏感信息
+            if not should_exclude and isinstance(var_value, str):
+                value_lower = var_value.lower()
+                for pattern in exclude_patterns:
+                    if (pattern.lower() in value_lower and 
+                        len(var_value) < 100):  # 只检查短字符串
+                        should_exclude = True
+                        break
+            
+            if not should_exclude:
+                # 尝试转换为可序列化的格式
+                serializable_value = XMLRPCSerializer.convert_to_serializable(var_value)
+                # 注意：None值转换后仍然是None，但这是有效的结果
+                if serializable_value is not None or var_value is None:
+                    filtered_variables[var_name] = serializable_value
+                else:
+                    print(f"跳过不可序列化的变量: {var_name} "
+                          f"(类型: {type(var_value).__name__})")
+            else:
+                print(f"跳过敏感变量: {var_name}")
+        
+        return filtered_variables
+    
+    @staticmethod
+    def validate_xmlrpc_data(data: Any) -> bool:
+        """验证数据是否可以通过XML-RPC传输
+        
+        Args:
+            data: 要验证的数据
+            
+        Returns:
+            bool: 是否可以传输
+        """
+        try:
+            import xmlrpc.client
+            # 尝试序列化数据
+            xmlrpc.client.dumps((data,), allow_none=True)
+            return True
+        except Exception:
+            return False
+
+
+# 创建全局序列化器实例，方便直接使用
+xmlrpc_serializer = XMLRPCSerializer() 

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