pytest-dsl 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

pytest_dsl/core/dsl_executor.py

@@ -23,6 +23,14 @@ class ContinueException(Exception):
     pass
 
 
+class ReturnException(Exception):
+    """Return控制流异常"""
+
+    def __init__(self, return_value=None):
+        self.return_value = return_value
+        super().__init__(f"Return with value: {return_value}")
+
+
 class DSLExecutor:
     """DSL执行器，负责执行解析后的AST
 
@@ -30,12 +38,14 @@ class DSLExecutor:
     - PYTEST_DSL_KEEP_VARIABLES=1: 执行完成后保留变量，用于单元测试中检查变量值
     - PYTEST_DSL_KEEP_VARIABLES=0: (默认) 执行完成后清空变量，用于正常DSL执行
     """
+
     def __init__(self):
         """初始化DSL执行器"""
         self.variables = {}
         self.test_context = TestContext()
         self.test_context.executor = self  # 让 test_context 能够访问到 executor
-        self.variable_replacer = VariableReplacer(self.variables, self.test_context)
+        self.variable_replacer = VariableReplacer(
+            self.variables, self.test_context)
         self.imported_files = set()  # 跟踪已导入的文件，避免循环导入
 
     def set_current_data(self, data):
@@ -279,7 +289,8 @@ class DSLExecutor:
                     # 导入自定义关键字管理器
                     from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
                     # 注册自定义关键字
-                    custom_keyword_manager._register_custom_keyword(stmt, "current_file")
+                    custom_keyword_manager._register_custom_keyword(
+                        stmt, "current_file")
 
     def _handle_start(self, node):
         """处理开始节点"""
@@ -377,7 +388,8 @@ class DSLExecutor:
             # 当 PYTEST_DSL_KEEP_VARIABLES=1 时，保留变量（用于单元测试）
             # 否则清空变量（用于正常DSL执行）
             import os
-            keep_variables = os.environ.get('PYTEST_DSL_KEEP_VARIABLES', '0') == '1'
+            keep_variables = os.environ.get(
+                'PYTEST_DSL_KEEP_VARIABLES', '0') == '1'
 
             if not keep_variables:
                 self.variables.clear()
@@ -387,7 +399,11 @@ class DSLExecutor:
     def _handle_statements(self, node):
         """处理语句列表"""
         for stmt in node.children:
-            self.execute(stmt)
+            try:
+                self.execute(stmt)
+            except ReturnException as e:
+                # 将return异常向上传递，不在这里处理
+                raise e
 
     @allure.step("变量赋值")
     def _handle_assignment(self, node):
@@ -491,6 +507,14 @@ class DSLExecutor:
                         attachment_type=allure.attachment_type.TEXT
                     )
                     continue
+                except ReturnException as e:
+                    # 遇到return语句，将异常向上传递
+                    allure.attach(
+                        f"在 {var_name} = {i} 时遇到return语句，退出函数",
+                        name="循环Return",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    raise e
 
     def _execute_keyword_call(self, node):
         """执行关键字调用"""
@@ -537,11 +561,12 @@ class DSLExecutor:
         Args:
             node: Return节点
 
-        Returns:
-            表达式求值结果
+        Raises:
+            ReturnException: 抛出异常来实现return控制流
         """
         expr_node = node.children[0]
-        return self.eval_expression(expr_node)
+        return_value = self.eval_expression(expr_node)
+        raise ReturnException(return_value)
 
     @allure.step("执行break语句")
     def _handle_break(self, node):
@@ -580,7 +605,8 @@ class DSLExecutor:
         if condition:
             # 执行if分支
             with allure.step("执行if分支"):
-                return self.execute(node.children[1])
+                self.execute(node.children[1])
+                return
 
         # 如果if条件为假，检查elif分支
         for i in range(2, len(node.children)):
@@ -591,13 +617,15 @@ class DSLExecutor:
                 elif_condition = self.eval_expression(child.children[0])
                 if elif_condition:
                     with allure.step(f"执行elif分支 {i-1}"):
-                        return self.execute(child.children[1])
+                        self.execute(child.children[1])
+                        return
 
             # 如果是普通的statements节点（else分支）
             elif not hasattr(child, 'type') or child.type == 'Statements':
                 # 这是else分支，只有在所有前面的条件都为假时才执行
                 with allure.step("执行else分支"):
-                    return self.execute(child)
+                    self.execute(child)
+                    return
 
         # 如果所有条件都为假且没有else分支，则不执行任何操作
         return None
@@ -634,7 +662,8 @@ class DSLExecutor:
         with allure.step(f"执行远程关键字: {alias}|{keyword_name}"):
             try:
                 # 执行远程关键字
-                result = remote_keyword_manager.execute_remote_keyword(alias, keyword_name, **kwargs)
+                result = remote_keyword_manager.execute_remote_keyword(
+                    alias, keyword_name, **kwargs)
                 allure.attach(
                     f"远程关键字参数: {kwargs}\n"
                     f"远程关键字结果: {result}",
@@ -730,6 +759,7 @@ class DSLExecutor:
             return handler(node)
         raise Exception(f"未知的节点类型: {node.type}")
 
+
 def read_file(filename):
     """读取 DSL 文件内容"""
     with open(filename, 'r', encoding='utf-8') as f:

pytest_dsl/remote/__init__.py

@@ -0,0 +1,7 @@
+"""
+Remote module for pytest-dsl.
+
+This module provides remote keyword server functionality.
+"""
+
+__version__ = "0.9.0" 

pytest_dsl/remote/hook_manager.py

@@ -0,0 +1,155 @@
+"""远程服务器Hook管理器
+
+该模块提供了远程服务器的hook机制，支持在服务器生命周期的关键点执行自定义逻辑。
+"""
+
+import logging
+from typing import Dict, List, Callable, Any
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class HookType(Enum):
+    """Hook类型枚举"""
+    SERVER_STARTUP = "server_startup"
+    SERVER_SHUTDOWN = "server_shutdown"
+    BEFORE_KEYWORD_EXECUTION = "before_keyword_execution"
+    AFTER_KEYWORD_EXECUTION = "after_keyword_execution"
+
+
+class HookContext:
+    """Hook执行上下文"""
+    
+    def __init__(self, hook_type: HookType, **kwargs):
+        self.hook_type = hook_type
+        self.data = kwargs
+        self.shared_variables = kwargs.get('shared_variables', {})
+        
+    def get(self, key: str, default=None):
+        """获取上下文数据"""
+        return self.data.get(key, default)
+        
+    def set(self, key: str, value: Any):
+        """设置上下文数据"""
+        self.data[key] = value
+        
+    def get_shared_variable(self, name: str, default=None):
+        """获取共享变量"""
+        return self.shared_variables.get(name, default)
+
+
+class HookManager:
+    """Hook管理器"""
+    
+    def __init__(self):
+        self._hooks: Dict[HookType, List[Callable]] = {
+            HookType.SERVER_STARTUP: [],
+            HookType.SERVER_SHUTDOWN: [],
+            HookType.BEFORE_KEYWORD_EXECUTION: [],
+            HookType.AFTER_KEYWORD_EXECUTION: []
+        }
+        
+    def register_hook(self, hook_type: HookType, hook_func: Callable):
+        """注册hook函数
+        
+        Args:
+            hook_type: Hook类型
+            hook_func: Hook函数，接收HookContext参数
+        """
+        if hook_type not in self._hooks:
+            raise ValueError(f"不支持的hook类型: {hook_type}")
+            
+        self._hooks[hook_type].append(hook_func)
+        logger.info(f"注册hook: {hook_type.value} -> {hook_func.__name__}")
+        
+    def execute_hooks(self, hook_type: HookType, **context_data) -> HookContext:
+        """执行指定类型的所有hook
+        
+        Args:
+            hook_type: Hook类型
+            **context_data: 传递给hook的上下文数据
+            
+        Returns:
+            HookContext: 执行后的上下文
+        """
+        context = HookContext(hook_type, **context_data)
+        
+        hooks = self._hooks.get(hook_type, [])
+        if not hooks:
+            logger.debug(f"没有注册的hook: {hook_type.value}")
+            return context
+            
+        logger.debug(f"执行{len(hooks)}个hook: {hook_type.value}")
+        
+        for hook_func in hooks:
+            try:
+                logger.debug(f"执行hook: {hook_func.__name__}")
+                hook_func(context)
+            except Exception as e:
+                logger.error(f"Hook执行失败 {hook_func.__name__}: {str(e)}")
+                # 继续执行其他hook，不因为一个hook失败而中断
+                
+        return context
+        
+    def get_registered_hooks(self, hook_type: HookType = None) -> Dict[HookType, List[str]]:
+        """获取已注册的hook信息
+        
+        Args:
+            hook_type: 指定hook类型，None表示获取所有
+            
+        Returns:
+            Dict: hook类型到函数名列表的映射
+        """
+        result = {}
+        
+        if hook_type:
+            hooks = self._hooks.get(hook_type, [])
+            result[hook_type] = [hook.__name__ for hook in hooks]
+        else:
+            for ht, hooks in self._hooks.items():
+                result[ht] = [hook.__name__ for hook in hooks]
+                
+        return result
+        
+    def clear_hooks(self, hook_type: HookType = None):
+        """清除hook
+        
+        Args:
+            hook_type: 指定hook类型，None表示清除所有
+        """
+        if hook_type:
+            self._hooks[hook_type] = []
+            logger.info(f"清除hook: {hook_type.value}")
+        else:
+            for ht in self._hooks:
+                self._hooks[ht] = []
+            logger.info("清除所有hook")
+
+
+# 全局hook管理器实例
+hook_manager = HookManager()
+
+
+def register_startup_hook(func: Callable):
+    """装饰器：注册服务器启动hook"""
+    hook_manager.register_hook(HookType.SERVER_STARTUP, func)
+    return func
+
+
+def register_shutdown_hook(func: Callable):
+    """装饰器：注册服务器关闭hook"""
+    hook_manager.register_hook(HookType.SERVER_SHUTDOWN, func)
+    return func
+
+
+def register_before_keyword_hook(func: Callable):
+    """装饰器：注册关键字执行前hook"""
+    hook_manager.register_hook(HookType.BEFORE_KEYWORD_EXECUTION, func)
+    return func
+
+
+def register_after_keyword_hook(func: Callable):
+    """装饰器：注册关键字执行后hook"""
+    hook_manager.register_hook(HookType.AFTER_KEYWORD_EXECUTION, func)
+    return func

pytest_dsl/remote/keyword_client.py

@@ -0,0 +1,376 @@
+import xmlrpc.client
+from functools import partial
+import logging
+
+from pytest_dsl.core.keyword_manager import keyword_manager, Parameter
+
+# 配置日志
+logger = logging.getLogger(__name__)
+
+class RemoteKeywordClient:
+    """远程关键字客户端，用于连接远程关键字服务器并执行关键字"""
+
+    def __init__(self, url='http://localhost:8270/', api_key=None, alias=None, sync_config=None):
+        self.url = url
+        self.server = xmlrpc.client.ServerProxy(url, allow_none=True)
+        self.keyword_cache = {}
+        self.param_mappings = {}  # 存储每个关键字的参数映射
+        self.api_key = api_key
+        self.alias = alias or url.replace('http://', '').replace('https://', '').split(':')[0]
+
+        # 变量传递配置（简化版）
+        self.sync_config = sync_config or {
+            'sync_global_vars': True,   # 连接时传递全局变量（g_开头）
+            'sync_yaml_vars': True,     # 连接时传递YAML配置变量
+            'yaml_sync_keys': None,     # 指定要同步的YAML键列表，None表示同步所有（除了排除的）
+            'yaml_exclude_patterns': [  # 排除包含这些模式的YAML变量
+                'password', 'secret', 'key', 'token', 'credential', 'auth',
+                'private', 'remote_servers'  # 排除远程服务器配置避免循环
+            ]
+        }
+
+    def connect(self):
+        """连接到远程服务器并获取可用关键字"""
+        try:
+            print(f"RemoteKeywordClient: 正在连接到远程服务器 {self.url}")
+            keyword_names = self.server.get_keyword_names()
+            print(f"RemoteKeywordClient: 获取到 {len(keyword_names)} 个关键字")
+            for name in keyword_names:
+                self._register_remote_keyword(name)
+
+            # 连接时传递变量到远程服务器
+            self._send_initial_variables()
+
+            logger.info(f"已连接到远程关键字服务器: {self.url}, 别名: {self.alias}")
+            print(f"RemoteKeywordClient: 成功连接到远程服务器 {self.url}, 别名: {self.alias}")
+            return True
+        except Exception as e:
+            error_msg = f"连接远程关键字服务器失败: {str(e)}"
+            logger.error(error_msg)
+            print(f"RemoteKeywordClient: {error_msg}")
+            return False
+
+    def _register_remote_keyword(self, name):
+        """注册远程关键字到本地关键字管理器"""
+        # 获取关键字参数信息
+        try:
+            param_names = self.server.get_keyword_arguments(name)
+            doc = self.server.get_keyword_documentation(name)
+
+            print(f"注册远程关键字: {name}, 参数: {param_names}")
+
+            # 创建参数列表
+            parameters = []
+            param_mapping = {}  # 为每个关键字创建参数映射
+
+            for param_name in param_names:
+                # 确保参数名称正确映射
+                # 这里我们保持原始参数名称，但在执行时会进行正确映射
+                parameters.append({
+                    'name': param_name,
+                    'mapping': param_name,  # 保持原始参数名称
+                    'description': f'远程关键字参数: {param_name}'
+                })
+                # 添加到参数映射
+                param_mapping[param_name] = param_name
+
+            # 添加步骤名称参数，这是所有关键字都应该有的
+            if not any(p['name'] == '步骤名称' for p in parameters):
+                parameters.append({
+                    'name': '步骤名称',
+                    'mapping': 'step_name',
+                    'description': '自定义的步骤名称，用于在报告中显示'
+                })
+                param_mapping['步骤名称'] = 'step_name'
+
+            # 创建远程关键字执行函数
+            remote_func = partial(self._execute_remote_keyword, name=name)
+            remote_func.__doc__ = doc
+
+            # 注册到关键字管理器，使用别名前缀
+            remote_keyword_name = f"{self.alias}|{name}"
+            keyword_manager._keywords[remote_keyword_name] = {
+                'func': remote_func,
+                'mapping': {p['name']: p['mapping'] for p in parameters},
+                'parameters': [Parameter(**p) for p in parameters],
+                'remote': True,  # 标记为远程关键字
+                'alias': self.alias,
+                'original_name': name
+            }
+
+            # 缓存关键字信息
+            self.keyword_cache[name] = {
+                'parameters': param_names,  # 注意这里只缓存原始参数，不包括步骤名称
+                'doc': doc
+            }
+
+            # 保存参数映射
+            self.param_mappings[name] = param_mapping
+
+            logger.debug(f"已注册远程关键字: {remote_keyword_name}")
+        except Exception as e:
+            logger.error(f"注册远程关键字 {name} 失败: {str(e)}")
+
+    def _execute_remote_keyword(self, **kwargs):
+        """执行远程关键字"""
+        name = kwargs.pop('name')
+
+        # 移除context参数，因为它不能被序列化
+        if 'context' in kwargs:
+            kwargs.pop('context', None)
+
+        # 移除step_name参数，这是自动添加的，不需要传递给远程服务器
+        if 'step_name' in kwargs:
+            kwargs.pop('step_name', None)
+
+        # 打印调试信息
+        print(f"远程关键字调用: {name}, 参数: {kwargs}")
+
+        # 创建反向映射字典，用于检查参数是否已经映射
+        reverse_mapping = {}
+
+        # 使用动态注册的参数映射
+        if name in self.param_mappings:
+            param_mapping = self.param_mappings[name]
+            print(f"使用动态参数映射: {param_mapping}")
+            for cn_name, en_name in param_mapping.items():
+                reverse_mapping[en_name] = cn_name
+        else:
+            # 如果没有任何映射，使用原始参数名
+            param_mapping = None
+            print(f"没有找到参数映射，使用原始参数名")
+
+        # 映射参数名称
+        mapped_kwargs = {}
+        if param_mapping:
+            for k, v in kwargs.items():
+                if k in param_mapping:
+                    mapped_key = param_mapping[k]
+                    mapped_kwargs[mapped_key] = v
+                    print(f"参数映射: {k} -> {mapped_key} = {v}")
+                else:
+                    mapped_kwargs[k] = v
+        else:
+            mapped_kwargs = kwargs
+
+        # 确保参数名称正确映射
+        # 获取关键字的参数信息
+        if name in self.keyword_cache:
+            param_names = self.keyword_cache[name]['parameters']
+            print(f"远程关键字 {name} 的参数列表: {param_names}")
+
+            # 不再显示警告信息，因为参数已经在服务器端正确处理
+            # 服务器端会使用默认值或者报错，客户端不需要重复警告
+
+        # 执行远程调用
+        # 检查是否需要传递API密钥
+        if self.api_key:
+            result = self.server.run_keyword(name, mapped_kwargs, self.api_key)
+        else:
+            result = self.server.run_keyword(name, mapped_kwargs)
+
+        print(f"远程关键字执行结果: {result}")
+
+        if result['status'] == 'PASS':
+            return_data = result['return']
+
+            # 处理新的返回格式
+            if isinstance(return_data, dict):
+                # 处理捕获的变量 - 这里需要访问本地上下文
+                if 'captures' in return_data and return_data['captures']:
+                    print(f"远程关键字捕获的变量: {return_data['captures']}")
+
+                # 处理会话状态
+                if 'session_state' in return_data and return_data['session_state']:
+                    print(f"远程关键字会话状态: {return_data['session_state']}")
+
+                # 处理响应数据
+                if 'response' in return_data and return_data['response']:
+                    print(f"远程关键字响应数据: 已接收")
+
+                # 检查是否为新的统一返回格式（包含captures等字段）
+                if 'captures' in return_data or 'session_state' in return_data or 'metadata' in return_data:
+                    # 返回完整的新格式，让DSL执行器处理变量捕获
+                    return return_data
+                elif 'result' in return_data:
+                    # 返回主要结果，保持向后兼容
+                    return return_data['result']
+                else:
+                    return return_data
+
+            return return_data
+        else:
+            error_msg = result.get('error', '未知错误')
+            traceback = '\n'.join(result.get('traceback', []))
+            raise Exception(f"远程关键字执行失败: {error_msg}\n{traceback}")
+
+    def _send_initial_variables(self):
+        """连接时发送初始变量到远程服务器"""
+        try:
+            variables_to_send = {}
+
+            # 收集全局变量
+            if self.sync_config.get('sync_global_vars', True):
+                variables_to_send.update(self._collect_global_variables())
+
+            # 收集YAML变量
+            if self.sync_config.get('sync_yaml_vars', True):
+                variables_to_send.update(self._collect_yaml_variables())
+
+            if variables_to_send:
+                try:
+                    # 调用远程服务器的变量接收接口
+                    result = self.server.sync_variables_from_client(variables_to_send, self.api_key)
+                    if result.get('status') == 'success':
+                        print(f"成功传递 {len(variables_to_send)} 个变量到远程服务器")
+                    else:
+                        print(f"传递变量到远程服务器失败: {result.get('error', '未知错误')}")
+                except Exception as e:
+                    print(f"调用远程变量接口失败: {str(e)}")
+            else:
+                print("没有需要传递的变量")
+
+        except Exception as e:
+            logger.warning(f"初始变量传递失败: {str(e)}")
+            print(f"初始变量传递失败: {str(e)}")
+
+    def _collect_global_variables(self):
+        """收集全局变量"""
+        from pytest_dsl.core.global_context import global_context
+        variables = {}
+
+        # 获取所有全局变量（包括g_开头的变量）
+        try:
+            # 这里需要访问全局上下文的内部存储
+            # 由于GlobalContext使用文件存储，我们需要直接读取
+            import json
+            import os
+            from filelock import FileLock
+
+            storage_file = global_context._storage_file
+            lock_file = global_context._lock_file
+
+            if os.path.exists(storage_file):
+                with FileLock(lock_file):
+                    with open(storage_file, 'r', encoding='utf-8') as f:
+                        stored_vars = json.load(f)
+                        # 只同步g_开头的全局变量
+                        for name, value in stored_vars.items():
+                            if name.startswith('g_'):
+                                variables[name] = value
+        except Exception as e:
+            logger.warning(f"收集全局变量失败: {str(e)}")
+
+        return variables
+
+    def _collect_yaml_variables(self):
+        """收集YAML配置变量"""
+        from pytest_dsl.core.yaml_vars import yaml_vars
+        variables = {}
+
+        try:
+            # 获取所有YAML变量
+            yaml_data = yaml_vars._variables
+            if yaml_data:
+                # 检查同步配置中是否指定了特定的键
+                sync_keys = self.sync_config.get('yaml_sync_keys', None)
+                exclude_patterns = self.sync_config.get('yaml_exclude_patterns', [
+                    'password', 'secret', 'key', 'token', 'credential', 'auth',
+                    'private', 'remote_servers'  # 排除远程服务器配置避免循环
+                ])
+
+                if sync_keys:
+                    # 如果指定了特定键，只传递这些键，直接使用原始变量名
+                    for key in sync_keys:
+                        if key in yaml_data:
+                            variables[key] = yaml_data[key]
+                else:
+                    # 传递所有YAML变量，但排除敏感信息
+                    for key, value in yaml_data.items():
+                        # 检查是否包含敏感信息
+                        key_lower = key.lower()
+                        should_exclude = False
+
+                        for pattern in exclude_patterns:
+                            if pattern.lower() in key_lower:
+                                should_exclude = True
+                                break
+
+                        # 如果值是字符串，也检查是否包含敏感信息
+                        if not should_exclude and isinstance(value, str):
+                            value_lower = value.lower()
+                            for pattern in exclude_patterns:
+                                if pattern.lower() in value_lower and len(value) < 100:  # 只检查短字符串
+                                    should_exclude = True
+                                    break
+
+                        if not should_exclude:
+                            # 直接使用原始变量名，不添加yaml_前缀，实现无缝传递
+                            variables[key] = value
+                            print(f"传递YAML变量: {key}")
+                        else:
+                            print(f"跳过敏感YAML变量: {key}")
+
+        except Exception as e:
+            logger.warning(f"收集YAML变量失败: {str(e)}")
+
+        return variables
+
+
+
+# 远程关键字客户端管理器
+class RemoteKeywordManager:
+    """远程关键字客户端管理器，管理多个远程服务器连接"""
+
+    def __init__(self):
+        self.clients = {}  # 别名 -> 客户端实例
+
+    def register_remote_server(self, url, alias, api_key=None, sync_config=None):
+        """注册远程关键字服务器
+
+        Args:
+            url: 服务器URL
+            alias: 服务器别名
+            api_key: API密钥(可选)
+            sync_config: 变量同步配置(可选)
+
+        Returns:
+            bool: 是否成功连接
+        """
+        print(f"RemoteKeywordManager: 正在注册远程服务器 {url} 别名 {alias}")
+        client = RemoteKeywordClient(url=url, api_key=api_key, alias=alias, sync_config=sync_config)
+        success = client.connect()
+
+        if success:
+            print(f"RemoteKeywordManager: 成功连接到远程服务器 {url}")
+            self.clients[alias] = client
+        else:
+            print(f"RemoteKeywordManager: 连接远程服务器 {url} 失败")
+
+        return success
+
+    def get_client(self, alias):
+        """获取指定别名的客户端实例"""
+        return self.clients.get(alias)
+
+    def execute_remote_keyword(self, alias, keyword_name, **kwargs):
+        """执行远程关键字
+
+        Args:
+            alias: 服务器别名
+            keyword_name: 关键字名称
+            **kwargs: 关键字参数
+
+        Returns:
+            执行结果
+        """
+        client = self.get_client(alias)
+        if not client:
+            raise Exception(f"未找到别名为 {alias} 的远程服务器")
+
+        return client._execute_remote_keyword(name=keyword_name, **kwargs)
+
+
+
+# 创建全局远程关键字管理器实例
+remote_keyword_manager = RemoteKeywordManager()