pytest-dsl 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

pytest_dsl/cli.py

@@ -5,12 +5,14 @@ pytest-dsl命令行入口
 """
 
 import sys
+import argparse
 import pytest
 from pathlib import Path
 
 from pytest_dsl.core.lexer import get_lexer
 from pytest_dsl.core.parser import get_parser
 from pytest_dsl.core.dsl_executor import DSLExecutor
+from pytest_dsl.core.yaml_vars import yaml_vars
 
 
 def read_file(filename):
@@ -19,20 +21,54 @@ def read_file(filename):
         return f.read()
 
 
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(description='执行DSL测试文件')
+    parser.add_argument('dsl_file', help='要执行的DSL文件路径')
+    parser.add_argument('--yaml-vars', action='append', default=[], 
+                       help='YAML变量文件路径，可以指定多个文件 (例如: --yaml-vars vars1.yaml --yaml-vars vars2.yaml)')
+    parser.add_argument('--yaml-vars-dir', default=None,
+                       help='YAML变量文件目录路径，将加载该目录下所有.yaml文件')
+    
+    return parser.parse_args()
+
+
+def load_yaml_variables(args):
+    """从命令行参数加载YAML变量"""
+    # 加载单个YAML文件
+    if args.yaml_vars:
+        yaml_vars.load_yaml_files(args.yaml_vars)
+        print(f"已加载YAML变量文件: {', '.join(args.yaml_vars)}")
+    
+    # 加载目录中的YAML文件
+    if args.yaml_vars_dir:
+        yaml_vars_dir = args.yaml_vars_dir
+        try:
+            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)}")
+        except NotADirectoryError:
+            print(f"YAML变量目录不存在: {yaml_vars_dir}")
+            sys.exit(1)
+
+
 def main():
     """命令行入口点"""
-    if len(sys.argv) < 2:
-        print("用法: python -m pytest_dsl.cli <dsl_file>")
-        sys.exit(1)
-        
-    filename = sys.argv[1]
+    args = parse_args()
+    
+    # 加载YAML变量
+    load_yaml_variables(args)
     
     lexer = get_lexer()
     parser = get_parser()
     executor = DSLExecutor()
     
     try:
-        dsl_code = read_file(filename)
+        dsl_code = read_file(args.dsl_file)
         ast = parser.parse(dsl_code, lexer=lexer)
         executor.execute(ast)
     except Exception as e:

pytest_dsl/core/__init__.py

@@ -0,0 +1,7 @@
+# 导入关键模块确保它们被初始化
+from pytest_dsl.core.keyword_manager import keyword_manager
+from pytest_dsl.core.global_context import global_context
+from pytest_dsl.core.yaml_vars import yaml_vars
+
+# 导入自定义关键字管理器
+from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager

pytest_dsl/core/custom_keyword_manager.py

@@ -0,0 +1,213 @@
+from typing import Dict, Any, List, Optional
+import os
+import pathlib
+from pytest_dsl.core.lexer import get_lexer
+from pytest_dsl.core.parser import get_parser, Node
+from pytest_dsl.core.dsl_executor import DSLExecutor
+from pytest_dsl.core.keyword_manager import keyword_manager
+from pytest_dsl.core.context import TestContext
+
+
+class CustomKeywordManager:
+    """自定义关键字管理器
+    
+    负责加载和注册自定义关键字
+    """
+    
+    def __init__(self):
+        """初始化自定义关键字管理器"""
+        self.resource_cache = {}  # 缓存已加载的资源文件
+        self.resource_paths = []  # 资源文件搜索路径
+    
+    def add_resource_path(self, path: str) -> None:
+        """添加资源文件搜索路径
+        
+        Args:
+            path: 资源文件路径
+        """
+        if path not in self.resource_paths:
+            self.resource_paths.append(path)
+    
+    def load_resource_file(self, file_path: str) -> None:
+        """加载资源文件
+        
+        Args:
+            file_path: 资源文件路径
+        """
+        # 规范化路径，解决路径叠加的问题
+        file_path = os.path.normpath(file_path)
+        
+        # 如果已经缓存，则跳过
+        absolute_path = os.path.abspath(file_path)
+        if absolute_path in self.resource_cache:
+            return
+        
+        # 读取文件内容
+        if not os.path.exists(file_path):
+            # 尝试在资源路径中查找
+            for resource_path in self.resource_paths:
+                full_path = os.path.join(resource_path, file_path)
+                if os.path.exists(full_path):
+                    file_path = full_path
+                    absolute_path = os.path.abspath(file_path)
+                    break
+            else:
+                # 如果文件不存在，尝试在根项目目录中查找
+                # 一般情况下文件路径可能是相对于项目根目录的
+                project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+                full_path = os.path.join(project_root, file_path)
+                if os.path.exists(full_path):
+                    file_path = full_path
+                    absolute_path = os.path.abspath(file_path)
+                else:
+                    raise FileNotFoundError(f"资源文件不存在: {file_path}")
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # 解析资源文件
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(content, lexer=lexer)
+            
+            # 标记为已加载
+            self.resource_cache[absolute_path] = True
+            
+            # 处理导入指令
+            self._process_imports(ast, os.path.dirname(file_path))
+            
+            # 注册关键字
+            self._register_keywords(ast, file_path)
+        except Exception as e:
+            print(f"资源文件 {file_path} 加载失败: {str(e)}")
+            raise
+    
+    def _process_imports(self, ast: Node, base_dir: str) -> None:
+        """处理资源文件中的导入指令
+        
+        Args:
+            ast: 抽象语法树
+            base_dir: 基础目录
+        """
+        if ast.type != 'Start' or not ast.children:
+            return
+        
+        metadata_node = ast.children[0]
+        if metadata_node.type != 'Metadata':
+            return
+        
+        for item in metadata_node.children:
+            if item.type == '@import':
+                imported_file = item.value
+                # 处理相对路径
+                if not os.path.isabs(imported_file):
+                    imported_file = os.path.join(base_dir, imported_file)
+                    
+                # 规范化路径，避免路径叠加问题
+                imported_file = os.path.normpath(imported_file)
+                
+                # 递归加载导入的资源文件
+                self.load_resource_file(imported_file)
+    
+    def _register_keywords(self, ast: Node, file_path: str) -> None:
+        """从AST中注册关键字
+        
+        Args:
+            ast: 抽象语法树
+            file_path: 文件路径
+        """
+        if ast.type != 'Start' or len(ast.children) < 2:
+            return
+        
+        # 遍历语句节点
+        statements_node = ast.children[1]
+        if statements_node.type != 'Statements':
+            return
+        
+        for node in statements_node.children:
+            if node.type == 'CustomKeyword':
+                self._register_custom_keyword(node, file_path)
+    
+    def _register_custom_keyword(self, node: Node, file_path: str) -> None:
+        """注册自定义关键字
+        
+        Args:
+            node: 关键字节点
+            file_path: 资源文件路径
+        """
+        # 提取关键字信息
+        keyword_name = node.value
+        params_node = node.children[0]
+        body_node = node.children[1]
+        
+        # 构建参数列表
+        parameters = []
+        param_mapping = {}
+        param_defaults = {}  # 存储参数默认值
+        
+        for param in params_node if params_node else []:
+            param_name = param.value
+            param_default = None
+            
+            # 检查是否有默认值
+            if param.children and param.children[0]:
+                param_default = param.children[0].value
+                param_defaults[param_name] = param_default  # 保存默认值
+            
+            # 添加参数定义
+            parameters.append({
+                'name': param_name,
+                'mapping': param_name,  # 中文参数名和内部参数名相同
+                'description': f'自定义关键字参数 {param_name}'
+            })
+            
+            param_mapping[param_name] = param_name
+        
+        # 注册自定义关键字到关键字管理器
+        @keyword_manager.register(keyword_name, parameters)
+        def custom_keyword_executor(**kwargs):
+            """自定义关键字执行器"""
+            # 创建一个新的DSL执行器
+            executor = DSLExecutor()
+            
+            # 获取传递的上下文
+            context = kwargs.get('context')
+            if context:
+                executor.test_context = context
+            
+            # 先应用默认值
+            for param_name, default_value in param_defaults.items():
+                executor.variables[param_name] = default_value
+                executor.test_context.set(param_name, default_value)
+            
+            # 然后应用传入的参数值（覆盖默认值）
+            for param_name, param_mapping_name in param_mapping.items():
+                if param_mapping_name in kwargs:
+                    # 确保参数值在标准变量和测试上下文中都可用
+                    executor.variables[param_name] = kwargs[param_mapping_name]
+                    executor.test_context.set(param_name, kwargs[param_mapping_name])
+            
+            # 执行关键字体中的语句
+            result = None
+            try:
+                for stmt in body_node.children:
+                    # 检查是否是return语句
+                    if stmt.type == 'Return':
+                        # 对表达式求值
+                        result = executor.eval_expression(stmt.children[0])
+                        break
+                    else:
+                        # 执行普通语句
+                        executor.execute(stmt)
+            except Exception as e:
+                print(f"执行自定义关键字 {keyword_name} 时发生错误: {str(e)}")
+                raise
+            
+            return result
+        
+        print(f"已注册自定义关键字: {keyword_name} 来自文件: {file_path}")
+
+
+# 创建全局自定义关键字管理器实例
+custom_keyword_manager = CustomKeywordManager() 

pytest_dsl/core/dsl_executor.py

@@ -26,6 +26,7 @@ class DSLExecutor:
         self.test_context = TestContext()
         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):
         """设置当前测试数据集"""
@@ -92,6 +93,12 @@ class DSLExecutor:
         elif expr_node.type == 'BooleanExpr':
             # 处理布尔值表达式
             return expr_node.value
+        elif expr_node.type == 'ComparisonExpr':
+            # 处理比较表达式
+            return self._eval_comparison_expr(expr_node)
+        elif expr_node.type == 'ArithmeticExpr':
+            # 处理算术表达式
+            return self._eval_arithmetic_expr(expr_node)
         else:
             raise Exception(f"无法求值的表达式类型: {expr_node.type}")
     
@@ -100,8 +107,12 @@ class DSLExecutor:
         if isinstance(value, Node):
             return self.eval_expression(value)
         elif isinstance(value, str):
+            # 如果是ID类型的变量名
+            if value in self.variable_replacer.local_variables:
+                return self.variable_replacer.local_variables[value]
+            
             # 定义变量引用模式
-            pattern = r'\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}'
+            pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)\}'
             # 检查整个字符串是否完全匹配单一变量引用模式
             match = re.fullmatch(pattern, value)
             if match:
@@ -112,6 +123,86 @@ 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
+        elif operator == '<':
+            return left_value < right_value
+        elif operator == '>=':
+            return left_value >= right_value
+        elif operator == '<=':
+            return left_value <= right_value
+        elif operator == '==':
+            return left_value == right_value
+        elif operator == '!=':
+            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 == '+':
+            # 对于字符串，+是连接操作
+            if isinstance(left_value, str) or isinstance(right_value, str):
+                return str(left_value) + str(right_value)
+            return left_value + right_value
+        elif operator == '-':
+            return left_value - right_value
+        elif operator == '*':
+            # 如果其中一个是字符串，另一个是数字，则进行字符串重复
+            if isinstance(left_value, str) and isinstance(right_value, (int, float)):
+                return left_value * int(right_value)
+            elif isinstance(right_value, str) and isinstance(left_value, (int, float)):
+                return right_value * int(left_value)
+            return left_value * right_value
+        elif operator == '/':
+            # 除法时检查除数是否为0
+            if right_value == 0:
+                raise Exception("除法错误: 除数不能为0")
+            return left_value / right_value
+        else:
+            raise Exception(f"未知的算术操作符: {operator}")
+    
     def _get_variable(self, var_name):
         """获取变量值，优先从本地变量获取，如果不存在则尝试从全局上下文获取"""
         return self.variable_replacer.get_variable(var_name)
@@ -119,6 +210,21 @@ class DSLExecutor:
     def _replace_variables_in_string(self, value):
         """替换字符串中的变量引用"""
         return self.variable_replacer.replace_in_string(value)
+    
+    def _handle_custom_keywords_in_file(self, node):
+        """处理文件中的自定义关键字定义
+        
+        Args:
+            node: Start节点
+        """
+        if len(node.children) > 1 and node.children[1].type == 'Statements':
+            statements_node = node.children[1]
+            for stmt in statements_node.children:
+                if stmt.type == 'CustomKeyword':
+                    # 导入自定义关键字管理器
+                    from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
+                    # 注册自定义关键字
+                    custom_keyword_manager._register_custom_keyword(stmt, "current_file")
 
     def _handle_start(self, node):
         """处理开始节点"""
@@ -133,9 +239,14 @@ class DSLExecutor:
                 if child.type == 'Metadata':
                     for item in child.children:
                         metadata[item.type] = item.value
+                        # 处理导入指令
+                        if item.type == '@import':
+                            self._handle_import(item.value)
                 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)
             
@@ -154,6 +265,25 @@ class DSLExecutor:
             # 测试用例执行完成后清空上下文
             self.test_context.clear()
 
+    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
+            custom_keyword_manager.load_resource_file(file_path)
+            self.imported_files.add(file_path)
+        except Exception as e:
+            print(f"导入资源文件失败: {file_path}, 错误: {str(e)}")
+            raise
+
     def _execute_test_iteration(self, metadata, node, teardown_node):
         """执行测试迭代"""
         try:
@@ -305,6 +435,41 @@ class DSLExecutor:
         """处理清理操作"""
         self.execute(node.children[0])
 
+    @allure.step("执行返回语句")
+    def _handle_return(self, node):
+        """处理return语句
+        
+        Args:
+            node: Return节点
+            
+        Returns:
+            表达式求值结果
+        """
+        expr_node = node.children[0]
+        return self.eval_expression(expr_node)
+
+    @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分支
+            with allure.step("执行if分支"):
+                return self.execute(node.children[1])
+        elif len(node.children) > 2:
+            # 如果存在else分支且条件为假，则执行else分支
+            with allure.step("执行else分支"):
+                return self.execute(node.children[2])
+        
+        # 如果条件为假且没有else分支，则不执行任何操作
+        return None
+
     def execute(self, node):
         """执行AST节点"""
         handlers = {
@@ -315,7 +480,10 @@ class DSLExecutor:
             'AssignmentKeywordCall': self._handle_assignment_keyword_call,
             'ForLoop': self._handle_for_loop,
             'KeywordCall': self._execute_keyword_call,
-            'Teardown': self._handle_teardown
+            'Teardown': self._handle_teardown,
+            'Return': self._handle_return,
+            'IfStatement': self._handle_if_statement,
+            'CustomKeyword': lambda _: None  # 添加对CustomKeyword节点的处理，只需注册不需执行
         }
         
         handler = handlers.get(node.type)
@@ -326,4 +494,4 @@ class DSLExecutor:
 def read_file(filename):
     """读取 DSL 文件内容"""
     with open(filename, 'r', encoding='utf-8') as f:
-        return f.read()
+        return f.read()