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

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)

pytest_dsl/core/variable_utils.py

@@ -1,50 +1,54 @@
+"""变量替换工具模块
+
+该模块提供了高级的变量替换功能，支持复杂的变量访问语法。
+"""
+
 import re
 import json
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 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: 测试上下文对象
+            test_context: 测试上下文
         """
         self.local_variables = local_variables or {}
-        self._test_context = test_context or TestContext()
+        self._test_context = test_context
 
     @property
     def test_context(self) -> TestContext:
-        """获取测试上下文，确保始终使用最新的上下文对象
+        """获取测试上下文，如果没有提供则尝试从关键字管理器获取"""
+        if self._test_context:
+            return self._test_context
 
-        如果上下文对象中包含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
+        # 尝试从关键字管理器获取当前上下文
+        try:
+            from pytest_dsl.core.keyword_manager import keyword_manager
+            return getattr(keyword_manager, 'current_context', None)
+        except ImportError:
+            return None
 
     def get_variable(self, var_name: str) -> Any:
-        """获取变量值，按照优先级查找
+        """获取变量值，按优先级顺序查找
+
+        查找顺序：
+        1. 本地变量
+        2. 测试上下文
+        3. 全局上下文（包含YAML变量的访问）
 
         Args:
             var_name: 变量名
 
         Returns:
-            变量值，如果变量不存在则抛出 KeyError
+            变量值
 
         Raises:
             KeyError: 当变量不存在时
@@ -54,17 +58,13 @@ class VariableReplacer:
             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)
+        # 从测试上下文中获取（优先级高于YAML变量）
+        context = self.test_context
+        if context and context.has(var_name):
+            value = 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)
-
-        # 从全局上下文获取
+        # 从全局上下文获取（包含对YAML变量的统一访问）
         if global_context.has_variable(var_name):
             value = global_context.get_variable(var_name)
             return self._convert_value(value)
@@ -130,7 +130,8 @@ class VariableReplacer:
             try:
                 var_value = self._parse_variable_path(var_ref)
                 # 替换变量引用
-                result = result[:match.start()] + str(var_value) + result[match.end():]
+                result = result[:match.start()] + str(var_value) + \
+                    result[match.end():]
             except (KeyError, IndexError, TypeError) as e:
                 raise KeyError(f"无法解析变量引用 '${{{var_ref}}}': {str(e)}")
 
@@ -170,7 +171,8 @@ class VariableReplacer:
 
         # 逐步访问路径
         for part in path_parts[1:]:
-            current_value = self._access_value(current_value, part, root_var_name)
+            current_value = self._access_value(
+                current_value, part, root_var_name)
 
         return current_value
 
@@ -258,14 +260,16 @@ class VariableReplacer:
                         raise KeyError(f"字典中不存在键 '{key}'")
                     return current_value[key]
                 else:
-                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用字符串键访问")
+                    raise TypeError(
+                        f"无法在 {type(current_value).__name__} 类型上使用字符串键访问")
 
             # 处理数字索引
             try:
                 index = int(key_content)
                 if isinstance(current_value, (list, tuple)):
                     if index >= len(current_value) or index < -len(current_value):
-                        raise IndexError(f"数组索引 {index} 超出范围，数组长度为 {len(current_value)}")
+                        raise IndexError(
+                            f"数组索引 {index} 超出范围，数组长度为 {len(current_value)}")
                     return current_value[index]
                 elif isinstance(current_value, dict):
                     # 字典也可以用数字键
@@ -274,7 +278,8 @@ class VariableReplacer:
                         raise KeyError(f"字典中不存在键 '{index}' 或 '{str_key}'")
                     return current_value.get(index, current_value.get(str_key))
                 else:
-                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用索引访问")
+                    raise TypeError(
+                        f"无法在 {type(current_value).__name__} 类型上使用索引访问")
             except ValueError:
                 raise ValueError(f"无效的索引格式: '{key_content}'")
 
@@ -283,7 +288,8 @@ class VariableReplacer:
             if isinstance(current_value, dict) and access_token in current_value:
                 return current_value[access_token]
             else:
-                raise KeyError(f"无法访问属性 '{access_token}'，当前值类型是 {type(current_value).__name__}")
+                raise KeyError(
+                    f"无法访问属性 '{access_token}'，当前值类型是 {type(current_value).__name__}")
 
     def replace_in_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """递归替换字典中的变量引用
@@ -303,7 +309,8 @@ class VariableReplacer:
         result = {}
         for key, value in data.items():
             # 替换键中的变量
-            new_key = self.replace_in_string(key) if isinstance(key, str) else key
+            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
@@ -409,4 +416,4 @@ class VariableReplacer:
             return yaml.dump(replaced_data, allow_unicode=True)
         except:
             # 如果YAML解析失败，直接作为字符串处理
-            return self.replace_in_string(yaml_str)
+            return self.replace_in_string(yaml_str)

pytest_dsl/core/yaml_loader.py

@@ -31,50 +31,91 @@ def add_yaml_options(parser):
 
 
 def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None,
-                                  project_root=None, environment=None):
-    """从参数加载YAML变量文件（通用函数）
+                                  project_root=None, environment=None,
+                                  auto_load_default=None):
+    """从命令行参数加载YAML变量
 
     Args:
         yaml_files: YAML文件列表
         yaml_vars_dir: YAML变量目录路径
-        project_root: 项目根目录（用于默认config目录）
+        project_root: 项目根目录
         environment: 环境名称（用于hook加载）
+        auto_load_default: 是否自动加载默认配置
+                          None - 根据用户输入智能判断
+                          True - 强制加载默认配置  
+                          False - 不加载默认配置
     """
-    # 首先尝试通过hook加载变量
+    # 智能判断是否应该加载默认配置
+    if auto_load_default is None:
+        # 如果用户指定了具体的YAML文件，不自动加载默认配置
+        # 如果用户指定了具体的目录，也不自动加载默认配置
+        user_specified_files = bool(yaml_files)
+        user_specified_dir = bool(yaml_vars_dir)
+        auto_load_default = not (user_specified_files or user_specified_dir)
+
+        if not auto_load_default:
+            print("🎯 检测到用户指定了配置，跳过默认配置自动加载")
+        else:
+            print("📁 未指定配置，将自动加载默认配置目录")
+
+    # 首先尝试通过hook加载变量（最高优先级）
     hook_variables = _load_variables_through_hooks(
         project_root=project_root, environment=environment)
 
     if hook_variables:
-        print(f"通过Hook加载了 {len(hook_variables)} 个变量")
+        print(f"🔌 通过Hook加载了 {len(hook_variables)} 个变量")
         # 将hook变量加载到yaml_vars中
         yaml_vars._variables.update(hook_variables)
 
-    # 加载单个YAML文件
+    # 加载用户指定的YAML文件（第二优先级）
     if yaml_files:
         yaml_vars.load_yaml_files(yaml_files)
-        print(f"已加载YAML变量文件: {', '.join(yaml_files)}")
-
-    # 加载目录中的YAML文件
-    if yaml_vars_dir is None and project_root:
-        # 默认使用项目根目录下的config目录
-        yaml_vars_dir = str(Path(project_root) / 'config')
-        print(f"使用默认YAML变量目录: {yaml_vars_dir}")
-
-    if yaml_vars_dir and 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:
-            # 过滤出当前目录的文件
-            if yaml_vars_dir:
+        print(f"📄 已加载用户指定的YAML文件: {', '.join(yaml_files)}")
+
+    # 加载用户指定的目录中的YAML文件（第三优先级）
+    if 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:
+                # 过滤出当前目录的文件
                 dir_files = [f for f in loaded_files if Path(
                     f).parent == Path(yaml_vars_dir)]
                 if dir_files:
-                    print(f"目录中加载的文件: {', '.join(dir_files)}")
-            else:
-                print(f"加载的文件: {', '.join(loaded_files)}")
-    elif yaml_vars_dir:
-        print(f"YAML变量目录不存在: {yaml_vars_dir}")
+                    print(f"   目录中加载的文件: {', '.join(dir_files)}")
+        else:
+            print(f"⚠️ 用户指定的YAML目录不存在: {yaml_vars_dir}")
+
+    # 自动加载默认配置（最低优先级，仅在用户未指定配置时）
+    if auto_load_default:
+        default_yaml_vars_dir = None
+        if project_root:
+            # 默认使用项目根目录下的config目录
+            default_yaml_vars_dir = str(Path(project_root) / 'config')
+            print(f"🏠 使用默认YAML变量目录: {default_yaml_vars_dir}")
+
+        if default_yaml_vars_dir and Path(default_yaml_vars_dir).exists():
+            yaml_vars.load_from_directory(default_yaml_vars_dir)
+            print(f"📁 已加载默认YAML变量目录: {default_yaml_vars_dir}")
+            loaded_files = yaml_vars.get_loaded_files()
+            if loaded_files:
+                # 过滤出默认目录的文件
+                dir_files = [f for f in loaded_files if Path(
+                    f).parent == Path(default_yaml_vars_dir)]
+                if dir_files:
+                    print(f"   默认目录中加载的文件: {', '.join(dir_files)}")
+        elif default_yaml_vars_dir:
+            print(f"📁 默认YAML变量目录不存在: {default_yaml_vars_dir}")
+
+    # 显示最终加载的变量汇总
+    all_loaded_files = yaml_vars.get_loaded_files()
+    if all_loaded_files:
+        print(f"✅ 变量加载完成，共加载 {len(all_loaded_files)} 个文件")
+        if len(yaml_vars._variables) > 0:
+            print(f"📊 总共加载了 {len(yaml_vars._variables)} 个变量")
+    else:
+        print("⚠️ 未加载任何YAML变量文件")
 
     # 加载完YAML变量后，自动连接远程服务器
     load_remote_servers_from_yaml()
@@ -203,37 +244,136 @@ def load_yaml_variables(config):
     )
 
 
-def load_remote_servers_from_yaml():
-    """从YAML变量中加载远程服务器配置"""
+def load_remote_servers_from_yaml(variable_source=None):
+    """从YAML变量中加载远程服务器配置
+
+    Args:
+        variable_source: 自定义变量源，如果不提供则使用全局上下文
+    """
     try:
         from pytest_dsl.remote.keyword_client import remote_keyword_manager
 
-        # 获取远程服务器配置
-        remote_servers = yaml_vars.get_variable('remote_servers')
-        if not remote_servers:
-            return
+        # 支持自定义变量源
+        if variable_source and callable(variable_source):
+            variables = variable_source()
+            remote_servers = variables.get(
+                'remote_servers') if isinstance(variables, dict) else None
+        else:
+            # 使用默认的全局上下文
+            from pytest_dsl.core.global_context import global_context
+            remote_servers = global_context.get_variable('remote_servers')
 
-        print(f"发现 {len(remote_servers)} 个远程服务器配置")
+        if not remote_servers:
+            return []
+
+        # 支持两种格式：数组和字典
+        server_configs = []
+
+        if isinstance(remote_servers, list):
+            # 数组格式: [{'url': '...', 'alias': '...'}, ...]
+            server_configs = remote_servers
+            print(f"发现 {len(remote_servers)} 个远程服务器配置（数组格式）")
+        elif isinstance(remote_servers, dict):
+            # 字典格式: {'server1': {'url': '...', 'alias': '...'}, ...}
+            for server_name, server_config in remote_servers.items():
+                if isinstance(server_config, dict):
+                    # 如果没有指定alias，使用键名作为alias
+                    if 'alias' not in server_config:
+                        server_config = server_config.copy()
+                        server_config['alias'] = server_name
+                    server_configs.append(server_config)
+            print(f"发现 {len(server_configs)} 个远程服务器配置（字典格式）")
+        else:
+            print(
+                f"警告：remote_servers配置格式不支持，期望数组或字典，得到 {type(remote_servers)}")
+            return []
+
+        results = []
 
         # 注册远程服务器
-        for server_config in remote_servers:
+        for server_config in server_configs:
             if isinstance(server_config, dict):
                 url = server_config.get('url')
                 alias = server_config.get('alias')
                 api_key = server_config.get('api_key')
+                sync_config = server_config.get('sync_config')
 
                 if url and alias:
                     print(f"自动连接远程服务器: {alias} -> {url}")
                     success = remote_keyword_manager.register_remote_server(
-                        url, alias, api_key=api_key
+                        url, alias, api_key=api_key, sync_config=sync_config
                     )
                     if success:
                         print(f"✓ 远程服务器 {alias} 连接成功")
                     else:
                         print(f"✗ 远程服务器 {alias} 连接失败")
 
+                    results.append(
+                        {'alias': alias, 'url': url, 'success': success})
+                else:
+                    print(f"警告：服务器配置缺少必要字段 url 或 alias: {server_config}")
+
+        return results
+
     except ImportError:
         # 如果远程功能不可用，跳过
-        pass
+        return []
     except Exception as e:
         print(f"自动连接远程服务器时出现警告: {e}")
+        return []
+
+
+def register_remote_servers_from_config(servers_config, variable_providers=None):
+    """从配置注册远程服务器的独立函数
+
+    这个函数可以被其他系统独立调用，不依赖YAML配置。
+
+    Args:
+        servers_config: 服务器配置列表或单个配置
+        variable_providers: 变量提供者列表，用于同步自定义变量
+
+    Returns:
+        dict: 注册结果
+
+    Examples:
+        >>> # 单个服务器
+        >>> config = {'url': 'http://server:8270', 'alias': 'test'}
+        >>> result = register_remote_servers_from_config(config)
+
+        >>> # 多个服务器
+        >>> configs = [
+        ...     {'url': 'http://server1:8270', 'alias': 'server1'},
+        ...     {'url': 'http://server2:8270', 'alias': 'server2'}
+        ... ]
+        >>> results = register_remote_servers_from_config(configs)
+
+        >>> # 带变量提供者
+        >>> def my_vars():
+        ...     return {'env': 'prod', 'api_key': 'secret'}
+        >>> results = register_remote_servers_from_config(configs, [my_vars])
+    """
+    try:
+        from pytest_dsl.core.remote_server_registry import remote_server_registry
+
+        # 如果有变量提供者，先添加它们
+        if variable_providers:
+            remote_server_registry.clear_variable_providers()
+            for provider in variable_providers:
+                if callable(provider):
+                    remote_server_registry.add_variable_provider(provider)
+
+        # 确保servers_config是列表
+        if isinstance(servers_config, dict):
+            servers_config = [servers_config]
+        elif not isinstance(servers_config, list):
+            raise ValueError("servers_config必须是字典或字典列表")
+
+        # 使用注册器批量注册
+        return remote_server_registry.register_servers_from_config(servers_config)
+
+    except ImportError:
+        print("远程功能不可用，请检查依赖安装")
+        return {}
+    except Exception as e:
+        print(f"注册远程服务器时发生错误: {e}")
+        return {}

pytest_dsl/keywords/http_keywords.py

@@ -14,7 +14,6 @@ from typing import Dict, Any, Union
 
 from pytest_dsl.core.keyword_manager import keyword_manager
 from pytest_dsl.core.http_request import HTTPRequest
-from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.context import TestContext
 
 # 配置日志
@@ -293,8 +292,8 @@ def http_request(context, **kwargs):
     # 添加调试信息，检查客户端配置是否可用
     print(f"🌐 HTTP请求 - 客户端: {client_name}")
 
-    # 检查YAML变量中的http_clients配置（现在包含同步的变量）
-    http_clients_config = yaml_vars.get_variable("http_clients")
+    # 从context获取http_clients配置（统一的变量获取方式）
+    http_clients_config = context.get("http_clients")
     if http_clients_config:
         print(f"✓ 找到http_clients配置，包含 {len(http_clients_config)} 个客户端")
         if client_name in http_clients_config:
@@ -310,10 +309,15 @@ def http_request(context, **kwargs):
 
     with allure.step(f"发送HTTP请求 (客户端: {client_name}"
                      f"{', 会话: ' + session_name if session_name else ''})"):
+
+        # 确保http_client_manager有正确的context引用
+        from pytest_dsl.core.http_client import http_client_manager
+        http_client_manager.set_context(context)
+
         # 处理模板
         if template_name:
-            # 从YAML变量中获取模板
-            http_templates = yaml_vars.get_variable("http_templates") or {}
+            # 从context获取模板配置（统一的变量获取方式）
+            http_templates = context.get("http_templates") or {}
             template = http_templates.get(template_name)
 
             if not template: