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

pytest_dsl/__init__.py

@@ -12,7 +12,7 @@ pytest-dsl - 基于pytest的DSL测试框架
 - 自定义关键字支持
 """
 
-__version__ = "0.1.0"
+__version__ = "0.15.4"
 
 # 核心执行器
 from pytest_dsl.core.dsl_executor import DSLExecutor
@@ -47,6 +47,20 @@ from pytest_dsl.core.variable_utils import VariableReplacer
 # 自定义关键字管理器
 from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
 
+# 远程服务器注册器
+from pytest_dsl.core.remote_server_registry import (
+    remote_server_registry, RemoteServerRegistry,
+    register_remote_server_with_variables,
+    create_database_variable_provider,
+    create_config_file_variable_provider
+)
+
+# 远程服务器配置加载器
+from pytest_dsl.core.yaml_loader import (
+    load_remote_servers_from_yaml,
+    register_remote_servers_from_config
+)
+
 # 关键字加载器
 from pytest_dsl.core.keyword_loader import (
     keyword_loader, KeywordLoader,
@@ -61,6 +75,22 @@ from pytest_dsl.core.keyword_utils import (
     generate_html_report
 )
 
+# 远程关键字功能
+try:
+    from pytest_dsl.remote import (
+        remote_keyword_manager, RemoteKeywordManager, RemoteKeywordClient,
+        register_remote_server, register_multiple_servers
+    )
+    _REMOTE_AVAILABLE = True
+except ImportError:
+    # 如果远程功能依赖不可用，设置为None
+    remote_keyword_manager = None
+    RemoteKeywordManager = None
+    RemoteKeywordClient = None
+    register_remote_server = None
+    register_multiple_servers = None
+    _REMOTE_AVAILABLE = False
+
 # 便捷导入的别名
 Executor = DSLExecutor
 Validator = DSLValidator
@@ -106,6 +136,17 @@ __all__ = [
     'Node', 'get_parser', 'get_lexer',
     'TestContext', 'global_context',
     'VariableReplacer',
+
+    # 远程关键字功能（如果可用）
+    'remote_keyword_manager', 'RemoteKeywordManager', 'RemoteKeywordClient',
+    'register_remote_server', 'register_multiple_servers',
+
+    # 远程服务器注册器
+    'remote_server_registry', 'RemoteServerRegistry',
+    'register_remote_server_with_variables',
+    'create_database_variable_provider', 
+    'create_config_file_variable_provider',
+    'load_remote_servers_from_yaml', 'register_remote_servers_from_config',
 ]
 
 # 快捷函数
@@ -137,7 +178,8 @@ def parse_dsl(content: str) -> Node:
     return parser.parse(content, lexer=lexer)
 
 
-def execute_dsl(content: str, context: dict = None, enable_hooks: bool = True) -> any:
+def execute_dsl(content: str, context: dict = None,
+                enable_hooks: bool = True) -> any:
     """执行DSL内容的便捷函数
 
     Args:
@@ -158,7 +200,8 @@ def execute_dsl(content: str, context: dict = None, enable_hooks: bool = True) -
     return executor.execute(ast)
 
 
-def register_keyword(name: str, parameters: list = None, source_type: str = "external",
+def register_keyword(name: str, parameters: list = None,
+                     source_type: str = "external",
                      source_name: str = "user_defined"):
     """注册关键字的装饰器
 
@@ -198,6 +241,12 @@ def check_version_compatibility():
         pass
 
 
+# 远程功能检查
+def is_remote_available() -> bool:
+    """检查远程功能是否可用"""
+    return _REMOTE_AVAILABLE
+
+
 # 初始化时进行版本检查
 check_version_compatibility()
 

pytest_dsl/cli.py

@@ -165,11 +165,18 @@ def load_yaml_variables(args):
         environment = (os.environ.get('PYTEST_DSL_ENVIRONMENT') or
                        os.environ.get('ENVIRONMENT'))
 
+        # 智能判断是否应该加载默认配置
+        # 如果用户指定了YAML文件或目录，则不自动加载默认配置
+        user_specified_files = bool(args.yaml_vars)
+        user_specified_dir = bool(args.yaml_vars_dir)
+        auto_load_default = not (user_specified_files or user_specified_dir)
+
         load_yaml_variables_from_args(
             yaml_files=args.yaml_vars,
             yaml_vars_dir=args.yaml_vars_dir,
             project_root=os.getcwd(),  # CLI模式下使用当前工作目录作为项目根目录
-            environment=environment
+            environment=environment,
+            auto_load_default=auto_load_default  # 使用智能判断的结果
         )
     except Exception as e:
         print(f"加载YAML变量失败: {str(e)}")

pytest_dsl/core/context.py

@@ -1,18 +1,42 @@
 class TestContext:
     def __init__(self):
         self._data = {}
+        self._external_providers = []  # 外部变量提供者列表
 
     def set(self, key: str, value: any) -> None:
         """设置上下文变量"""
         self._data[key] = value
 
     def get(self, key: str, default=None) -> any:
-        """获取上下文变量，如果不存在返回默认值"""
-        return self._data.get(key, default)
+        """获取上下文变量，遵循变量优先级：本地变量 > 外部提供者变量"""
+        # 1. 首先检查本地变量
+        if key in self._data:
+            return self._data[key]
+
+        # 2. 检查外部提供者（按注册顺序）
+        for provider in self._external_providers:
+            if hasattr(provider, 'get_variable'):
+                value = provider.get_variable(key)
+                if value is not None:
+                    return value
+
+        # 3. 返回默认值
+        return default
 
     def has(self, key: str) -> bool:
-        """检查上下文变量是否存在"""
-        return key in self._data
+        """检查上下文变量是否存在（包括外部提供者）"""
+        # 检查本地变量
+        if key in self._data:
+            return True
+
+        # 检查外部提供者
+        for provider in self._external_providers:
+            if hasattr(provider, 'get_variable'):
+                value = provider.get_variable(key)
+                if value is not None:
+                    return True
+
+        return False
 
     def clear(self) -> None:
         """清空上下文"""
@@ -20,4 +44,34 @@ class TestContext:
 
     def get_local_variables(self) -> dict:
         """获取所有本地变量"""
-        return self._data 
+        return self._data
+
+    def register_external_variable_provider(self, provider) -> None:
+        """注册外部变量提供者
+
+        Args:
+            provider: 变量提供者，需要实现get_variable(key)方法
+        """
+        if provider not in self._external_providers:
+            self._external_providers.append(provider)
+
+    def sync_variables_from_external_sources(self) -> None:
+        """将外部变量提供者中的常用变量同步到本地缓存中，提高访问性能
+
+        这个方法会调用所有外部提供者的get_all_variables方法，
+        将常用变量缓存到本地_data字典中，以提高后续访问的性能。
+        注意：本地变量的优先级仍然高于外部变量。
+        """
+        for provider in self._external_providers:
+            if hasattr(provider, 'get_all_variables'):
+                try:
+                    # 获取提供者的所有变量
+                    external_vars = provider.get_all_variables()
+                    if isinstance(external_vars, dict):
+                        # 只同步那些本地还没有的变量，保持本地变量的优先级
+                        for key, value in external_vars.items():
+                            if key not in self._data:
+                                self._data[key] = value
+                except Exception as e:
+                    # 如果某个提供者同步失败，记录警告但继续处理其他提供者
+                    print(f"警告：同步外部变量提供者变量时发生错误: {e}")

pytest_dsl/core/custom_keyword_manager.py

@@ -212,7 +212,7 @@ class CustomKeywordManager:
             print(f"资源文件 {file_path} 加载失败: {str(e)}")
             raise
 
-    def _process_resource_file_content(self, content: str, 
+    def _process_resource_file_content(self, content: str,
                                        file_path: str) -> None:
         """处理资源文件内容
 
@@ -258,7 +258,7 @@ class CustomKeywordManager:
                 # 递归加载导入的资源文件
                 self.load_resource_file(imported_file)
 
-    def _register_keywords_from_ast(self, ast: Node, 
+    def _register_keywords_from_ast(self, ast: Node,
                                     source_name: str) -> None:
         """从AST中注册关键字（重构后的版本）
 
@@ -341,6 +341,12 @@ class CustomKeywordManager:
                     executor.test_context.set(
                         param_name, kwargs[param_mapping_name])
 
+            # 重要：创建变量替换器，使变量解析正常工作
+            from pytest_dsl.core.variable_utils import VariableReplacer
+            executor.variable_replacer = VariableReplacer(
+                executor.variables, executor.test_context
+            )
+
             # 执行关键字体中的语句
             result = None
             try:
@@ -357,7 +363,7 @@ class CustomKeywordManager:
 
         print(f"已注册自定义关键字: {keyword_name} 来自文件: {file_path}")
 
-    def register_keyword_from_dsl_content(self, dsl_content: str, 
+    def register_keyword_from_dsl_content(self, dsl_content: str,
                                           source_name: str = "DSL内容") -> list:
         """从DSL内容注册关键字（公共方法）
 
@@ -379,8 +385,8 @@ class CustomKeywordManager:
 
             # 收集注册前的关键字列表
             existing_keywords = (
-                set(keyword_manager._keywords.keys()) 
-                if hasattr(keyword_manager, '_keywords') 
+                set(keyword_manager._keywords.keys())
+                if hasattr(keyword_manager, '_keywords')
                 else set()
             )
 
@@ -389,8 +395,8 @@ class CustomKeywordManager:
 
             # 计算新注册的关键字
             new_keywords = (
-                set(keyword_manager._keywords.keys()) 
-                if hasattr(keyword_manager, '_keywords') 
+                set(keyword_manager._keywords.keys())
+                if hasattr(keyword_manager, '_keywords')
                 else set()
             )
             registered_keywords = list(new_keywords - existing_keywords)
@@ -405,7 +411,7 @@ class CustomKeywordManager:
             raise
 
     def register_specific_keyword_from_dsl_content(
-            self, keyword_name: str, dsl_content: str, 
+            self, keyword_name: str, dsl_content: str,
             source_name: str = "DSL内容") -> bool:
         """从DSL内容注册指定的关键字（公共方法）
 

pytest_dsl/core/dsl_executor.py

@@ -72,6 +72,10 @@ class DSLExecutor:
         self.variables = {}
         self.test_context = TestContext()
         self.test_context.executor = self  # 让 test_context 能够访问到 executor
+
+        # 设置变量提供者，实现YAML变量等外部变量源的注入
+        self._setup_variable_providers()
+
         self.variable_replacer = VariableReplacer(
             self.variables, self.test_context)
         self.imported_files = set()  # 跟踪已导入的文件，避免循环导入
@@ -348,7 +352,7 @@ class DSLExecutor:
                     # 对于不包含 ${} 的普通字符串，检查是否为单纯的变量名
                     # 只有当字符串是有效的变量名格式且确实存在该变量时，才当作变量处理
                     if (re.match(r'^[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*$', value) and
-                        value in self.variable_replacer.local_variables):
+                            value in self.variable_replacer.local_variables):
                         return self.variable_replacer.local_variables[value]
                     else:
                         # 否则当作字符串字面量处理
@@ -366,6 +370,7 @@ class DSLExecutor:
         :param expr_node: 比较表达式节点
         :return: 比较结果（布尔值）
         """
+        operator = "未知"  # 设置默认值，避免UnboundLocalError
         try:
             left_value = self.eval_expression(expr_node.children[0])
             right_value = self.eval_expression(expr_node.children[1])
@@ -403,6 +408,7 @@ class DSLExecutor:
         :param expr_node: 算术表达式节点
         :return: 计算结果
         """
+        operator = "未知"  # 设置默认值，避免UnboundLocalError
         try:
             left_value = self.eval_expression(expr_node.children[0])
             right_value = self.eval_expression(expr_node.children[1])
@@ -903,7 +909,7 @@ class DSLExecutor:
             try:
                 # 准备参数（这里可能抛出参数解析异常）
                 kwargs = self._prepare_keyword_params(node, keyword_info)
-                
+
                 # 传递自定义步骤名称给KeywordManager，避免重复的allure步骤嵌套
                 kwargs['step_name'] = keyword_name  # 内层步骤只显示关键字名称
                 # 避免KeywordManager重复记录，由DSL执行器统一记录
@@ -927,7 +933,8 @@ class DSLExecutor:
                     if "参数解析异常" in core_error:
                         # 提取参数名和具体错误
                         import re
-                        match = re.search(r'参数解析异常 \(([^)]+)\): (.+)', core_error)
+                        match = re.search(
+                            r'参数解析异常 \(([^)]+)\): (.+)', core_error)
                         if match:
                             param_name, detailed_error = match.groups()
                             error_details = f"参数解析失败 ({param_name}): {detailed_error}{line_info}\n上下文: 执行KeywordCall节点"
@@ -938,7 +945,7 @@ class DSLExecutor:
                 else:
                     # 其他异常
                     error_details = f"执行KeywordCall节点: {str(e)}{line_info}\n上下文: 执行KeywordCall节点"
-                
+
                 allure.attach(
                     error_details,
                     name="DSL执行异常",
@@ -958,14 +965,14 @@ class DSLExecutor:
             for param in node.children[0]:
                 param_name = param.value
                 english_param_name = mapping.get(param_name, param_name)
-                
+
                 # 在子步骤中处理参数值解析，但不记录异常详情
                 with allure.step(f"解析参数: {param_name}"):
                     try:
                         # 对参数值进行变量替换
                         param_value = self.eval_expression(param.children[0])
                         kwargs[english_param_name] = param_value
-                        
+
                         # 只记录参数解析成功的简要信息
                         allure.attach(
                             f"参数名: {param_name}\n"
@@ -1144,7 +1151,8 @@ class DSLExecutor:
                             else:
                                 self.variable_replacer.local_variables[
                                     capture_var] = capture_value
-                                self.test_context.set(capture_var, capture_value)
+                                self.test_context.set(
+                                    capture_var, capture_value)
 
                         # 将主要结果赋值给指定变量
                         actual_result = main_result
@@ -1265,7 +1273,7 @@ class DSLExecutor:
             # 其他异常使用统一处理机制
             # 对于这些节点类型，异常已经在步骤中记录过了，跳过重复记录
             step_handled_nodes = {
-                'KeywordCall', 'Assignment', 'AssignmentKeywordCall', 
+                'KeywordCall', 'Assignment', 'AssignmentKeywordCall',
                 'ForLoop', 'RemoteKeywordCall', 'AssignmentRemoteKeywordCall'
             }
             skip_logging = node.type in step_handled_nodes
@@ -1312,6 +1320,18 @@ class DSLExecutor:
                 f"hooks_enabled={self.enable_hooks}, "
                 f"tracking_enabled={self.enable_tracking})")
 
+    def _setup_variable_providers(self):
+        """设置变量提供者，将外部变量源注入到TestContext中"""
+        try:
+            from .variable_providers import setup_context_with_default_providers
+            setup_context_with_default_providers(self.test_context)
+
+            # 同步常用变量到context中，提高访问性能
+            self.test_context.sync_variables_from_external_sources()
+        except ImportError as e:
+            # 如果导入失败，记录警告但不影响正常功能
+            print(f"警告：无法设置变量提供者: {e}")
+
     def _init_hooks(self):
         """初始化hook机制"""
         try:

pytest_dsl/core/global_context.py

@@ -4,7 +4,6 @@ import tempfile
 import allure
 from typing import Dict, Any, Optional
 from filelock import FileLock
-from .yaml_vars import yaml_vars
 
 
 class GlobalContext:
@@ -19,6 +18,20 @@ class GlobalContext:
             self._storage_dir, "global_vars.json")
         self._lock_file = os.path.join(self._storage_dir, "global_vars.lock")
 
+        # 初始化变量提供者（延迟加载，避免循环导入）
+        self._yaml_provider = None
+
+    def _get_yaml_provider(self):
+        """延迟获取YAML变量提供者，避免循环导入"""
+        if self._yaml_provider is None:
+            try:
+                from .variable_providers import YAMLVariableProvider
+                self._yaml_provider = YAMLVariableProvider()
+            except ImportError:
+                # 如果变量提供者不可用，创建一个空的提供者
+                self._yaml_provider = _EmptyProvider()
+        return self._yaml_provider
+
     def set_variable(self, name: str, value: Any) -> None:
         """设置全局变量"""
         with FileLock(self._lock_file):
@@ -34,8 +47,9 @@ class GlobalContext:
 
     def get_variable(self, name: str) -> Any:
         """获取全局变量，优先从YAML变量中获取"""
-        # 首先尝试从YAML变量中获取
-        yaml_value = yaml_vars.get_variable(name)
+        # 首先尝试从YAML变量中获取（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        yaml_value = yaml_provider.get_variable(name)
         if yaml_value is not None:
             return yaml_value
 
@@ -46,8 +60,9 @@ class GlobalContext:
 
     def has_variable(self, name: str) -> bool:
         """检查全局变量是否存在（包括YAML变量）"""
-        # 首先检查YAML变量
-        if yaml_vars.get_variable(name) is not None:
+        # 首先检查YAML变量（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        if yaml_provider.has_variable(name):
             return True
 
         # 然后检查全局变量存储
@@ -73,9 +88,11 @@ class GlobalContext:
         """清除所有全局变量（包括YAML变量）"""
         with FileLock(self._lock_file):
             self._save_variables({})
-        
-        # 清除YAML变量
-        yaml_vars.clear()
+
+        # 清除YAML变量（通过变量提供者）
+        yaml_provider = self._get_yaml_provider()
+        if hasattr(yaml_provider, 'clear'):
+            yaml_provider.clear()
 
         allure.attach(
             "清除所有全局变量",
@@ -99,5 +116,18 @@ class GlobalContext:
             json.dump(variables, f, ensure_ascii=False, indent=2)
 
 
+class _EmptyProvider:
+    """空的变量提供者，用作后备方案"""
+
+    def get_variable(self, key: str) -> Optional[Any]:
+        return None
+
+    def has_variable(self, key: str) -> bool:
+        return False
+
+    def clear(self):
+        pass
+
+
 # 创建全局上下文管理器实例
 global_context = GlobalContext()

pytest_dsl/core/http_client.py

@@ -3,7 +3,6 @@ import logging
 from typing import Dict, Any
 import requests
 from urllib.parse import urljoin
-from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.auth_provider import create_auth_provider
 
 logger = logging.getLogger(__name__)
@@ -289,6 +288,31 @@ class HTTPClientManager:
         """初始化客户端管理器"""
         self._clients: Dict[str, HTTPClient] = {}
         self._sessions: Dict[str, HTTPClient] = {}
+        self._context = None  # 添加context引用
+
+    def set_context(self, context):
+        """设置测试上下文，用于获取HTTP客户端配置
+
+        Args:
+            context: TestContext实例
+        """
+        self._context = context
+
+    def _get_http_clients_config(self) -> Dict[str, Any]:
+        """从context获取HTTP客户端配置
+
+        Returns:
+            HTTP客户端配置字典
+        """
+        if self._context:
+            return self._context.get("http_clients") or {}
+
+        # 如果没有context，尝试从yaml_vars获取（兼容性）
+        try:
+            from pytest_dsl.core.yaml_vars import yaml_vars
+            return yaml_vars.get_variable("http_clients") or {}
+        except ImportError:
+            return {}
 
     def create_client(self, config: Dict[str, Any]) -> HTTPClient:
         """从配置创建客户端
@@ -326,8 +350,8 @@ class HTTPClientManager:
         if name in self._clients:
             return self._clients[name]
 
-        # 从YAML变量中读取客户端配置
-        http_clients = yaml_vars.get_variable("http_clients") or {}
+        # 从context获取HTTP客户端配置（统一的变量获取方式）
+        http_clients = self._get_http_clients_config()
         client_config = http_clients.get(name)
 
         if not client_config:
@@ -377,7 +401,7 @@ class HTTPClientManager:
         return session
 
     def _get_client_config(self, name: str) -> Dict[str, Any]:
-        """从YAML变量获取客户端配置
+        """从context获取客户端配置
 
         Args:
             name: 客户端名称
@@ -385,7 +409,7 @@ class HTTPClientManager:
         Returns:
             客户端配置
         """
-        http_clients = yaml_vars.get_variable("http_clients") or {}
+        http_clients = self._get_http_clients_config()
         client_config = http_clients.get(name)
 
         if not client_config and name == "default":

pytest_dsl/core/keyword_utils.py

@@ -210,6 +210,13 @@ class KeywordFormatter:
             'parameters': keyword_info.parameters
         }
 
+        # 添加来源字段，优先显示项目自定义关键字的文件位置
+        if keyword_info.file_location:
+            keyword_data['source'] = keyword_info.file_location
+        else:
+            keyword_data['source'] = keyword_info.source_info.get(
+                'display_name', keyword_info.source_info.get('name', '未知'))
+
         # 远程关键字特殊信息
         if keyword_info.remote_info:
             keyword_data['remote'] = keyword_info.remote_info