pytest-dsl 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

pytest_dsl/core/dsl_executor.py

@@ -27,7 +27,7 @@ class DSLExecutor:
         self.test_context.executor = self  # 让 test_context 能够访问到 executor
         self.variable_replacer = VariableReplacer(self.variables, self.test_context)
         self.imported_files = set()  # 跟踪已导入的文件，避免循环导入
-        
+
     def set_current_data(self, data):
         """设置当前测试数据集"""
         if data:
@@ -35,30 +35,30 @@ class DSLExecutor:
             # 同时将数据添加到测试上下文
             for key, value in data.items():
                 self.test_context.set(key, value)
-        
+
     def _load_test_data(self, data_source):
         """加载测试数据
-        
+
         :param data_source: 数据源配置，包含 file 和 format 字段
         :return: 包含测试数据的列表
         """
         if not data_source:
             return [{}]  # 如果没有数据源，返回一个空的数据集
-            
+
         file_path = data_source['file']
         format_type = data_source['format']
-        
+
         if not os.path.exists(file_path):
             raise Exception(f"数据文件不存在: {file_path}")
-            
+
         if format_type.lower() == 'csv':
             return self._load_csv_data(file_path)
         else:
             raise Exception(f"不支持的数据格式: {format_type}")
-            
+
     def _load_csv_data(self, file_path):
         """加载CSV格式的测试数据
-        
+
         :param file_path: CSV文件路径
         :return: 包含测试数据的列表
         """
@@ -68,11 +68,11 @@ class DSLExecutor:
             for row in reader:
                 data_sets.append(row)
         return data_sets
-        
+
     def eval_expression(self, expr_node):
         """
         对表达式节点进行求值，返回表达式的值。
-        
+
         :param expr_node: AST中的表达式节点
         :return: 表达式求值后的结果
         :raises Exception: 当遇到未定义变量或无法求值的类型时抛出异常
@@ -101,7 +101,7 @@ class DSLExecutor:
             return self._eval_arithmetic_expr(expr_node)
         else:
             raise Exception(f"无法求值的表达式类型: {expr_node.type}")
-    
+
     def _eval_expression_value(self, value):
         """处理表达式值的具体逻辑"""
         if isinstance(value, Node):
@@ -110,7 +110,7 @@ class DSLExecutor:
             # 如果是ID类型的变量名
             if value in self.variable_replacer.local_variables:
                 return self.variable_replacer.local_variables[value]
-            
+
             # 定义变量引用模式
             pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)\}'
             # 检查整个字符串是否完全匹配单一变量引用模式
@@ -122,24 +122,24 @@ class DSLExecutor:
                 # 如果不是单一变量，则替换字符串中的所有变量引用
                 return self.variable_replacer.replace_in_string(value)
         return value
-    
+
     def _eval_comparison_expr(self, expr_node):
         """
         对比较表达式进行求值
-        
+
         :param expr_node: 比较表达式节点
         :return: 比较结果（布尔值）
         """
         left_value = self.eval_expression(expr_node.children[0])
         right_value = self.eval_expression(expr_node.children[1])
         operator = expr_node.value  # 操作符: >, <, >=, <=, ==, !=
-        
+
         # 尝试类型转换
         if isinstance(left_value, str) and str(left_value).isdigit():
             left_value = int(left_value)
         if isinstance(right_value, str) and str(right_value).isdigit():
             right_value = int(right_value)
-        
+
         # 根据操作符执行相应的比较操作
         if operator == '>':
             return left_value > right_value
@@ -155,31 +155,31 @@ class DSLExecutor:
             return left_value != right_value
         else:
             raise Exception(f"未知的比较操作符: {operator}")
-    
+
     def _eval_arithmetic_expr(self, expr_node):
         """
         对算术表达式进行求值
-        
+
         :param expr_node: 算术表达式节点
         :return: 计算结果
         """
         left_value = self.eval_expression(expr_node.children[0])
         right_value = self.eval_expression(expr_node.children[1])
         operator = expr_node.value  # 操作符: +, -, *, /
-        
+
         # 尝试类型转换 - 如果是字符串数字则转为数字
         if isinstance(left_value, str) and str(left_value).replace('.', '', 1).isdigit():
             left_value = float(left_value)
             # 如果是整数则转为整数
             if left_value.is_integer():
                 left_value = int(left_value)
-        
+
         if isinstance(right_value, str) and str(right_value).replace('.', '', 1).isdigit():
             right_value = float(right_value)
             # 如果是整数则转为整数
             if right_value.is_integer():
                 right_value = int(right_value)
-        
+
         # 进行相应的算术运算
         if operator == '+':
             # 对于字符串，+是连接操作
@@ -202,18 +202,48 @@ class DSLExecutor:
             return left_value / right_value
         else:
             raise Exception(f"未知的算术操作符: {operator}")
-    
+
     def _get_variable(self, var_name):
         """获取变量值，优先从本地变量获取，如果不存在则尝试从全局上下文获取"""
         return self.variable_replacer.get_variable(var_name)
-    
+
     def _replace_variables_in_string(self, value):
         """替换字符串中的变量引用"""
         return self.variable_replacer.replace_in_string(value)
-    
+
+    def _handle_remote_import(self, node):
+        """处理远程关键字导入
+
+        Args:
+            node: RemoteImport节点
+        """
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
+        remote_info = node.value
+        url = self._replace_variables_in_string(remote_info['url'])
+        alias = remote_info['alias']
+
+        print(f"正在连接远程关键字服务器: {url}, 别名: {alias}")
+
+        # 注册远程服务器
+        success = remote_keyword_manager.register_remote_server(url, alias)
+
+        if not success:
+            print(f"无法连接到远程关键字服务器: {url}")
+            raise Exception(f"无法连接到远程关键字服务器: {url}")
+
+        print(f"已成功连接到远程关键字服务器: {url}, 别名: {alias}")
+
+        allure.attach(
+            f"已连接到远程关键字服务器: {url}\n"
+            f"别名: {alias}",
+            name="远程关键字导入",
+            attachment_type=allure.attachment_type.TEXT
+        )
+
     def _handle_custom_keywords_in_file(self, node):
         """处理文件中的自定义关键字定义
-        
+
         Args:
             node: Start节点
         """
@@ -233,7 +263,7 @@ class DSLExecutor:
             self.test_context.clear()
             metadata = {}
             teardown_node = None
-            
+
             # 先处理元数据和找到teardown节点
             for child in node.children:
                 if child.type == 'Metadata':
@@ -242,14 +272,17 @@ class DSLExecutor:
                         # 处理导入指令
                         if item.type == '@import':
                             self._handle_import(item.value)
+                        # 处理远程关键字导入
+                        elif item.type == 'RemoteImport':
+                            self._handle_remote_import(item)
                 elif child.type == 'Teardown':
                     teardown_node = child
-            
+
              # 在_execute_test_iteration之前添加
             self._handle_custom_keywords_in_file(node)
             # 执行测试
             self._execute_test_iteration(metadata, node, teardown_node)
-            
+
         except Exception as e:
             # 如果是断言错误，直接抛出
             if isinstance(e, AssertionError):
@@ -267,14 +300,14 @@ class DSLExecutor:
 
     def _handle_import(self, file_path):
         """处理导入指令
-        
+
         Args:
             file_path: 资源文件路径
         """
         # 防止循环导入
         if file_path in self.imported_files:
             return
-        
+
         try:
             # 导入自定义关键字文件
             from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
@@ -297,12 +330,12 @@ class DSLExecutor:
             if '@tags' in metadata:
                 for tag in metadata['@tags']:
                     allure.dynamic.tag(tag.value)
-                
+
             # 执行所有非teardown节点
             for child in node.children:
                 if child.type != 'Teardown' and child.type != 'Metadata':
                     self.execute(child)
-                
+
             # 执行teardown
             if teardown_node:
                 with allure.step("执行清理操作"):
@@ -320,7 +353,7 @@ class DSLExecutor:
             # 否则清空变量（用于正常DSL执行）
             import os
             keep_variables = os.environ.get('PYTEST_DSL_KEEP_VARIABLES', '0') == '1'
-            
+
             if not keep_variables:
                 self.variables.clear()
                 # 同时清空测试上下文
@@ -336,7 +369,7 @@ class DSLExecutor:
         """处理赋值语句"""
         var_name = node.value
         expr_value = self.eval_expression(node.children[0])
-        
+
         # 检查变量名是否以g_开头，如果是则设置为全局变量
         if var_name.startswith('g_'):
             global_context.set_variable(var_name, expr_value)
@@ -361,22 +394,42 @@ class DSLExecutor:
         var_name = node.value
         keyword_call_node = node.children[0]
         result = self.execute(keyword_call_node)
-        
+
         if result is not None:
+            # 处理新的统一返回格式（支持远程关键字模式）
+            if isinstance(result, dict) and 'result' in result:
+                # 提取主要返回值
+                main_result = result['result']
+
+                # 处理captures字段中的变量
+                captures = result.get('captures', {})
+                for capture_var, capture_value in captures.items():
+                    if capture_var.startswith('g_'):
+                        global_context.set_variable(capture_var, capture_value)
+                    else:
+                        self.variable_replacer.local_variables[capture_var] = capture_value
+                        self.test_context.set(capture_var, capture_value)
+
+                # 将主要结果赋值给指定变量
+                actual_result = main_result
+            else:
+                # 传统格式，直接使用结果
+                actual_result = result
+
             # 检查变量名是否以g_开头，如果是则设置为全局变量
             if var_name.startswith('g_'):
-                global_context.set_variable(var_name, result)
+                global_context.set_variable(var_name, actual_result)
                 allure.attach(
-                    f"全局变量: {var_name}\n值: {result}",
+                    f"全局变量: {var_name}\n值: {actual_result}",
                     name="全局变量赋值",
                     attachment_type=allure.attachment_type.TEXT
                 )
             else:
                 # 存储在本地变量字典和测试上下文中
-                self.variable_replacer.local_variables[var_name] = result
-                self.test_context.set(var_name, result)  # 同时添加到测试上下文
+                self.variable_replacer.local_variables[var_name] = actual_result
+                self.test_context.set(var_name, actual_result)  # 同时添加到测试上下文
                 allure.attach(
-                    f"变量: {var_name}\n值: {result}",
+                    f"变量: {var_name}\n值: {actual_result}",
                     name="赋值详情",
                     attachment_type=allure.attachment_type.TEXT
                 )
@@ -389,7 +442,7 @@ class DSLExecutor:
         var_name = node.value
         start = self.eval_expression(node.children[0])
         end = self.eval_expression(node.children[1])
-        
+
         for i in range(int(start), int(end)):
             # 存储在本地变量字典和测试上下文中
             self.variable_replacer.local_variables[var_name] = i
@@ -403,9 +456,9 @@ class DSLExecutor:
         keyword_info = keyword_manager.get_keyword_info(keyword_name)
         if not keyword_info:
             raise Exception(f"未注册的关键字: {keyword_name}")
-            
+
         kwargs = self._prepare_keyword_params(node, keyword_info)
-        
+
         try:
             # 由于KeywordManager中的wrapper已经添加了allure.step和日志，这里不再重复添加
             result = keyword_manager.execute(keyword_name, **kwargs)
@@ -418,7 +471,7 @@ class DSLExecutor:
         """准备关键字调用参数"""
         mapping = keyword_info.get('mapping', {})
         kwargs = {'context': self.test_context}  # 默认传入context参数
-        
+
         # 检查是否有参数列表
         if node.children[0]:
             for param in node.children[0]:
@@ -427,7 +480,7 @@ class DSLExecutor:
                 # 对参数值进行变量替换
                 param_value = self.eval_expression(param.children[0])
                 kwargs[english_param_name] = param_value
-                
+
         return kwargs
 
     @allure.step("执行清理操作")
@@ -438,10 +491,10 @@ class DSLExecutor:
     @allure.step("执行返回语句")
     def _handle_return(self, node):
         """处理return语句
-        
+
         Args:
             node: Return节点
-            
+
         Returns:
             表达式求值结果
         """
@@ -451,12 +504,12 @@ class DSLExecutor:
     @allure.step("执行条件语句")
     def _handle_if_statement(self, node):
         """处理if-else语句
-        
+
         Args:
             node: IfStatement节点，包含条件表达式、if分支和可选的else分支
         """
         condition = self.eval_expression(node.children[0])
-        
+
         # 将条件转换为布尔值进行评估
         if condition:
             # 执行if分支
@@ -466,10 +519,112 @@ class DSLExecutor:
             # 如果存在else分支且条件为假，则执行else分支
             with allure.step("执行else分支"):
                 return self.execute(node.children[2])
-        
+
         # 如果条件为假且没有else分支，则不执行任何操作
         return None
 
+    def _execute_remote_keyword_call(self, node):
+        """执行远程关键字调用
+
+        Args:
+            node: RemoteKeywordCall节点
+
+        Returns:
+            执行结果
+        """
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
+        call_info = node.value
+        alias = call_info['alias']
+        keyword_name = call_info['keyword']
+
+        # 准备参数
+        params = []
+        if node.children and node.children[0]:
+            params = node.children[0]
+
+        kwargs = {}
+        for param in params:
+            param_name = param.value
+            param_value = self.eval_expression(param.children[0])
+            kwargs[param_name] = param_value
+
+        # 添加测试上下文
+        kwargs['context'] = self.test_context
+
+        with allure.step(f"执行远程关键字: {alias}|{keyword_name}"):
+            try:
+                # 执行远程关键字
+                result = remote_keyword_manager.execute_remote_keyword(alias, keyword_name, **kwargs)
+                allure.attach(
+                    f"远程关键字参数: {kwargs}\n"
+                    f"远程关键字结果: {result}",
+                    name="远程关键字执行详情",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                return result
+            except Exception as e:
+                # 记录错误并重新抛出
+                allure.attach(
+                    f"远程关键字执行失败: {str(e)}",
+                    name="远程关键字错误",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                raise
+
+    def _handle_assignment_remote_keyword_call(self, node):
+        """处理远程关键字调用赋值
+
+        Args:
+            node: AssignmentRemoteKeywordCall节点
+        """
+        var_name = node.value
+        remote_keyword_call_node = node.children[0]
+        result = self.execute(remote_keyword_call_node)
+
+        if result is not None:
+            # 注意：远程关键字客户端已经处理了新格式的返回值，
+            # 这里接收到的result应该已经是主要返回值，而不是完整的字典格式
+            # 但为了保险起见，我们仍然检查是否为新格式
+            if isinstance(result, dict) and 'result' in result:
+                # 如果仍然是新格式（可能是嵌套的远程调用），提取主要返回值
+                main_result = result['result']
+
+                # 处理captures字段中的变量
+                captures = result.get('captures', {})
+                for capture_var, capture_value in captures.items():
+                    if capture_var.startswith('g_'):
+                        global_context.set_variable(capture_var, capture_value)
+                    else:
+                        self.variable_replacer.local_variables[capture_var] = capture_value
+                        self.test_context.set(capture_var, capture_value)
+
+                # 将主要结果赋值给指定变量
+                actual_result = main_result
+            else:
+                # 传统格式或已经处理过的格式，直接使用结果
+                actual_result = result
+
+            # 检查变量名是否以g_开头，如果是则设置为全局变量
+            if var_name.startswith('g_'):
+                global_context.set_variable(var_name, actual_result)
+                allure.attach(
+                    f"全局变量: {var_name}\n值: {actual_result}",
+                    name="全局变量赋值",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+            else:
+                # 存储在本地变量字典和测试上下文中
+                self.variable_replacer.local_variables[var_name] = actual_result
+                self.test_context.set(var_name, actual_result)  # 同时添加到测试上下文
+                allure.attach(
+                    f"变量: {var_name}\n值: {actual_result}",
+                    name="赋值详情",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+        else:
+            raise Exception(f"远程关键字没有返回结果")
+
     def execute(self, node):
         """执行AST节点"""
         handlers = {
@@ -483,9 +638,12 @@ class DSLExecutor:
             'Teardown': self._handle_teardown,
             'Return': self._handle_return,
             'IfStatement': self._handle_if_statement,
-            'CustomKeyword': lambda _: None  # 添加对CustomKeyword节点的处理，只需注册不需执行
+            'CustomKeyword': lambda _: None,  # 添加对CustomKeyword节点的处理，只需注册不需执行
+            'RemoteImport': self._handle_remote_import,
+            'RemoteKeywordCall': self._execute_remote_keyword_call,
+            'AssignmentRemoteKeywordCall': self._handle_assignment_remote_keyword_call
         }
-        
+
         handler = handlers.get(node.type)
         if handler:
             return handler(node)
@@ -494,4 +652,4 @@ class DSLExecutor:
 def read_file(filename):
     """读取 DSL 文件内容"""
     with open(filename, 'r', encoding='utf-8') as f:
-        return f.read()
+        return f.read()