pytest-dsl 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

pytest_dsl/core/dsl_executor.py

@@ -11,6 +11,7 @@ from pytest_dsl.core.context import TestContext
 import pytest_dsl.keywords
 from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.variable_utils import VariableReplacer
+from pytest_dsl.remote.keyword_client import remote_keyword_manager
 
 
 class DSLExecutor:
@@ -27,7 +28,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 +36,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 +69,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 +102,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 +111,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 +123,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 +156,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 +203,46 @@ 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节点
+        """
+        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 +262,7 @@ class DSLExecutor:
             self.test_context.clear()
             metadata = {}
             teardown_node = None
-            
+
             # 先处理元数据和找到teardown节点
             for child in node.children:
                 if child.type == 'Metadata':
@@ -242,14 +271,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 +299,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 +329,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 +352,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 +368,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,7 +393,7 @@ class DSLExecutor:
         var_name = node.value
         keyword_call_node = node.children[0]
         result = self.execute(keyword_call_node)
-        
+
         if result is not None:
             # 检查变量名是否以g_开头，如果是则设置为全局变量
             if var_name.startswith('g_'):
@@ -389,7 +421,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 +435,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 +450,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 +459,7 @@ class DSLExecutor:
                 # 对参数值进行变量替换
                 param_value = self.eval_expression(param.children[0])
                 kwargs[english_param_name] = param_value
-                
+
         return kwargs
 
     @allure.step("执行清理操作")
@@ -438,10 +470,10 @@ class DSLExecutor:
     @allure.step("执行返回语句")
     def _handle_return(self, node):
         """处理return语句
-        
+
         Args:
             node: Return节点
-            
+
         Returns:
             表达式求值结果
         """
@@ -451,12 +483,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 +498,88 @@ 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:
+            执行结果
+        """
+        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:
+            # 检查变量名是否以g_开头，如果是则设置为全局变量
+            if var_name.startswith('g_'):
+                global_context.set_variable(var_name, result)
+                allure.attach(
+                    f"全局变量: {var_name}\n值: {result}",
+                    name="全局变量赋值",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+            else:
+                # 存储在本地变量字典和测试上下文中
+                self.variable_replacer.local_variables[var_name] = result
+                self.test_context.set(var_name, result)  # 同时添加到测试上下文
+                allure.attach(
+                    f"变量: {var_name}\n值: {result}",
+                    name="赋值详情",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+        else:
+            raise Exception(f"远程关键字没有返回结果")
+
     def execute(self, node):
         """执行AST节点"""
         handlers = {
@@ -483,9 +593,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 +607,4 @@ class DSLExecutor:
 def read_file(filename):
     """读取 DSL 文件内容"""
     with open(filename, 'r', encoding='utf-8') as f:
-        return f.read()
+        return f.read()

pytest_dsl/core/lexer.py

@@ -12,7 +12,8 @@ reserved = {
     'False': 'FALSE',   # 添加布尔值支持
     'return': 'RETURN',  # 添加return关键字支持
     'else': 'ELSE',   # 添加else关键字支持
-    'if': 'IF'  # 添加if关键字支持
+    'if': 'IF',  # 添加if关键字支持
+    'as': 'AS'   # 添加as关键字支持，用于远程关键字别名
 }
 
 # token 名称列表
@@ -38,6 +39,7 @@ tokens = [
     'DATA_KEYWORD',  # Add new token for @data keyword
     'KEYWORD_KEYWORD',  # 添加@keyword关键字
     'IMPORT_KEYWORD',   # 添加@import关键字
+    'REMOTE_KEYWORD',   # 添加@remote关键字
     'GT',        # 大于 >
     'LT',        # 小于 <
     'GE',        # 大于等于 >=
@@ -48,6 +50,7 @@ tokens = [
     'MINUS',     # 减法 -
     'TIMES',     # 乘法 *
     'DIVIDE',    # 除法 /
+    'PIPE',      # 管道符 |，用于远程关键字调用
 ] + list(reserved.values())
 
 # 正则表达式定义 token
@@ -72,6 +75,14 @@ t_DIVIDE = r'/'
 # 增加PLACEHOLDER规则，匹配 ${变量名} 格式
 t_PLACEHOLDER = r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*\}'
 
+# 添加管道符的正则表达式定义
+t_PIPE = r'\|'
+
+# 添加@remote关键字的token规则
+def t_REMOTE_KEYWORD(t):
+    r'@remote'
+    return t
+
 
 def t_DATE(t):
     r'\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}:\d{2})?'

pytest_dsl/core/parser.py

@@ -68,7 +68,8 @@ def p_metadata_item(p):
                     | AUTHOR_KEYWORD COLON metadata_value
                     | DATE_KEYWORD COLON DATE
                     | DATA_KEYWORD COLON data_source
-                    | IMPORT_KEYWORD COLON STRING'''
+                    | IMPORT_KEYWORD COLON STRING
+                    | REMOTE_KEYWORD COLON STRING AS ID'''
     if p[1] == '@tags':
         p[0] = Node(p[1], value=p[4])
     elif p[1] == '@data':
@@ -76,7 +77,12 @@ def p_metadata_item(p):
         data_info = p[3]  # 这是一个包含 file 和 format 的字典
         p[0] = Node(p[1], value=data_info, children=None)
     elif p[1] == '@import':
+        # 检查是否是远程导入格式
         p[0] = Node(p[1], value=p[3])
+    elif p[1] == '@remote':
+        # 对于远程关键字导入，存储URL和别名
+        print(f"解析远程关键字导入: URL={p[3]}, 别名={p[5]}")
+        p[0] = Node('RemoteImport', value={'url': p[3], 'alias': p[5]})
     else:
         p[0] = Node(p[1], value=p[3])
 
@@ -114,6 +120,7 @@ def p_statements(p):
 def p_statement(p):
     '''statement : assignment
                 | keyword_call
+                | remote_keyword_call
                 | loop
                 | custom_keyword
                 | return_statement
@@ -123,9 +130,12 @@ def p_statement(p):
 
 def p_assignment(p):
     '''assignment : ID EQUALS expression
-                 | ID EQUALS keyword_call'''
+                 | ID EQUALS keyword_call
+                 | ID EQUALS remote_keyword_call'''
     if isinstance(p[3], Node) and p[3].type == 'KeywordCall':
         p[0] = Node('AssignmentKeywordCall', [p[3]], p[1])
+    elif isinstance(p[3], Node) and p[3].type == 'RemoteKeywordCall':
+        p[0] = Node('AssignmentRemoteKeywordCall', [p[3]], p[1])
     else:
         p[0] = Node('Assignment', value=p[1], children=[p[3]])
 
@@ -284,7 +294,7 @@ def p_comparison_expr(p):
                       | expr_atom LE expr_atom
                       | expr_atom EQ expr_atom
                       | expr_atom NE expr_atom'''
-    
+
     # 根据规则索引判断使用的是哪个操作符
     if p.slice[2].type == 'GT':
         operator = '>'
@@ -301,7 +311,7 @@ def p_comparison_expr(p):
     else:
         print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
         operator = None
-    
+
     p[0] = Node('ComparisonExpr', [p[1], p[3]], operator)
 
 
@@ -310,7 +320,7 @@ def p_arithmetic_expr(p):
                        | expression MINUS expression
                        | expression TIMES expression
                        | expression DIVIDE expression'''
-    
+
     # 根据规则索引判断使用的是哪个操作符
     if p.slice[2].type == 'PLUS':
         operator = '+'
@@ -323,7 +333,7 @@ def p_arithmetic_expr(p):
     else:
         print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
         operator = None
-    
+
     p[0] = Node('ArithmeticExpr', [p[1], p[3]], operator)
 
 
@@ -337,3 +347,12 @@ def p_error(p):
 
 def get_parser(debug=False):
     return yacc.yacc(debug=debug)
+
+# 定义远程关键字调用的语法规则
+def p_remote_keyword_call(p):
+    '''remote_keyword_call : ID PIPE LBRACKET ID RBRACKET COMMA parameter_list
+                          | ID PIPE LBRACKET ID RBRACKET'''
+    if len(p) == 8:
+        p[0] = Node('RemoteKeywordCall', [p[7]], {'alias': p[1], 'keyword': p[4]})
+    else:
+        p[0] = Node('RemoteKeywordCall', [[]], {'alias': p[1], 'keyword': p[4]})