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

pytest_dsl/cli.py

@@ -5,12 +5,16 @@ pytest-dsl命令行入口
 """
 
 import sys
+import argparse
 import pytest
+import os
 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
+from pytest_dsl.core.auto_directory import SETUP_FILE_NAME, TEARDOWN_FILE_NAME, execute_hook_file
 
 
 def read_file(filename):
@@ -19,26 +23,121 @@ def read_file(filename):
         return f.read()
 
 
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(description='执行DSL测试文件')
+    parser.add_argument('path', help='要执行的DSL文件路径或包含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 execute_dsl_file(file_path, lexer, parser, executor):
+    """执行单个DSL文件"""
+    try:
+        print(f"执行文件: {file_path}")
+        dsl_code = read_file(file_path)
+        ast = parser.parse(dsl_code, lexer=lexer)
+        executor.execute(ast)
+        return True
+    except Exception as e:
+        print(f"执行失败 {file_path}: {e}")
+        return False
+
+
+def find_dsl_files(directory):
+    """查找目录中的所有DSL文件"""
+    dsl_files = []
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith(('.dsl', '.auto')) and file not in [SETUP_FILE_NAME, TEARDOWN_FILE_NAME]:
+                dsl_files.append(os.path.join(root, file))
+    return dsl_files
+
+
 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()
+    path = args.path
+    
+    # 加载YAML变量
+    load_yaml_variables(args)
     
     lexer = get_lexer()
     parser = get_parser()
     executor = DSLExecutor()
     
-    try:
-        dsl_code = read_file(filename)
-        ast = parser.parse(dsl_code, lexer=lexer)
-        executor.execute(ast)
-    except Exception as e:
-        print(f"执行失败: {e}")
+    # 检查路径是文件还是目录
+    if os.path.isfile(path):
+        # 执行单个文件
+        success = execute_dsl_file(path, lexer, parser, executor)
+        if not success:
+            sys.exit(1)
+    elif os.path.isdir(path):
+        # 执行目录中的所有DSL文件
+        print(f"执行目录: {path}")
+        
+        # 先执行目录的setup文件（如果存在）
+        setup_file = os.path.join(path, SETUP_FILE_NAME)
+        if os.path.exists(setup_file):
+            execute_hook_file(Path(setup_file), True, path)
+        
+        # 查找并执行所有DSL文件
+        dsl_files = find_dsl_files(path)
+        if not dsl_files:
+            print(f"目录中没有找到DSL文件: {path}")
+            sys.exit(1)
+            
+        print(f"找到 {len(dsl_files)} 个DSL文件")
+        
+        # 执行所有DSL文件
+        failures = 0
+        for file_path in dsl_files:
+            success = execute_dsl_file(file_path, lexer, parser, executor)
+            if not success:
+                failures += 1
+        
+        # 最后执行目录的teardown文件（如果存在）
+        teardown_file = os.path.join(path, TEARDOWN_FILE_NAME)
+        if os.path.exists(teardown_file):
+            execute_hook_file(Path(teardown_file), False, path)
+        
+        # 如果有失败的测试，返回非零退出码
+        if failures > 0:
+            print(f"总计 {failures}/{len(dsl_files)} 个测试失败")
+            sys.exit(1)
+        else:
+            print(f"所有 {len(dsl_files)} 个测试成功完成")
+    else:
+        print(f"路径不存在: {path}")
         sys.exit(1)
 
 
 if __name__ == '__main__':
-    main() 
+    main() 

pytest_dsl/core/dsl_executor.py

@@ -93,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}")
     
@@ -101,6 +107,10 @@ 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_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)\}'
             # 检查整个字符串是否完全匹配单一变量引用模式
@@ -113,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)
@@ -120,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):
         """处理开始节点"""
@@ -140,6 +245,8 @@ class DSLExecutor:
                 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)
             
@@ -341,6 +448,28 @@ class DSLExecutor:
         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 = {
@@ -352,7 +481,9 @@ class DSLExecutor:
             'ForLoop': self._handle_for_loop,
             'KeywordCall': self._execute_keyword_call,
             'Teardown': self._handle_teardown,
-            'Return': self._handle_return
+            'Return': self._handle_return,
+            'IfStatement': self._handle_if_statement,
+            'CustomKeyword': lambda _: None  # 添加对CustomKeyword节点的处理，只需注册不需执行
         }
         
         handler = handlers.get(node.type)
@@ -363,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()

pytest_dsl/core/lexer.py

@@ -10,7 +10,9 @@ reserved = {
     'using': 'USING',  # Add new keyword for data-driven testing
     'True': 'TRUE',    # 添加布尔值支持
     'False': 'FALSE',   # 添加布尔值支持
-    'return': 'RETURN'  # 添加return关键字支持
+    'return': 'RETURN',  # 添加return关键字支持
+    'else': 'ELSE',   # 添加else关键字支持
+    'if': 'IF'  # 添加if关键字支持
 }
 
 # token 名称列表
@@ -36,6 +38,16 @@ tokens = [
     'DATA_KEYWORD',  # Add new token for @data keyword
     'KEYWORD_KEYWORD',  # 添加@keyword关键字
     'IMPORT_KEYWORD',   # 添加@import关键字
+    'GT',        # 大于 >
+    'LT',        # 小于 <
+    'GE',        # 大于等于 >=
+    'LE',        # 小于等于 <=
+    'EQ',        # 等于 ==
+    'NE',        # 不等于 !=
+    'PLUS',      # 加法 +
+    'MINUS',     # 减法 -
+    'TIMES',     # 乘法 *
+    'DIVIDE',    # 除法 /
 ] + list(reserved.values())
 
 # 正则表达式定义 token
@@ -46,6 +58,16 @@ t_RBRACKET = r'\]'
 t_COLON = r':'
 t_COMMA = r','
 t_EQUALS = r'='
+t_GT = r'>'
+t_LT = r'<'
+t_GE = r'>='
+t_LE = r'<='
+t_EQ = r'=='
+t_NE = r'!='
+t_PLUS = r'\+'
+t_MINUS = r'-'
+t_TIMES = r'\*'
+t_DIVIDE = r'/'
 
 # 增加PLACEHOLDER规则，匹配 ${变量名} 格式
 t_PLACEHOLDER = r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*\}'

pytest_dsl/core/parser.py

@@ -12,23 +12,44 @@ class Node:
 # 定义优先级和结合性
 precedence = (
     ('left', 'COMMA'),
+    ('left', 'GT', 'LT', 'GE', 'LE', 'EQ', 'NE'),  # 比较运算符优先级
+    ('left', 'PLUS', 'MINUS'),  # 加减运算符优先级
+    ('left', 'TIMES', 'DIVIDE'),  # 乘除运算符优先级
     ('right', 'EQUALS'),
 )
 
 
 def p_start(p):
     '''start : metadata statements teardown
-             | metadata statements'''
+             | metadata statements
+             | statements teardown
+             | statements'''
 
     if len(p) == 4:
         p[0] = Node('Start', [p[1], p[2], p[3]])
+    elif len(p) == 3:
+        # 判断第二个元素是teardown还是statements
+        if p[2].type == 'Teardown':
+            p[0] = Node('Start', [Node('Metadata', []), p[1], p[2]])
+        else:
+            p[0] = Node('Start', [p[1], p[2]])
     else:
-        p[0] = Node('Start', [p[1], p[2]])
+        # 没有metadata和teardown
+        p[0] = Node('Start', [Node('Metadata', []), p[1]])
 
 
 def p_metadata(p):
-    '''metadata : metadata_items'''
-    p[0] = Node('Metadata', p[1])
+    '''metadata : metadata_items
+                | empty'''
+    if p[1]:
+        p[0] = Node('Metadata', p[1])
+    else:
+        p[0] = Node('Metadata', [])
+
+
+def p_empty(p):
+    '''empty :'''
+    p[0] = None
 
 
 def p_metadata_items(p):
@@ -95,7 +116,8 @@ def p_statement(p):
                 | keyword_call
                 | loop
                 | custom_keyword
-                | return_statement'''
+                | return_statement
+                | if_statement'''
     p[0] = p[1]
 
 
@@ -109,13 +131,31 @@ def p_assignment(p):
 
 
 def p_expression(p):
-    '''expression : NUMBER
-                  | STRING
-                  | PLACEHOLDER
-                  | ID
-                  | boolean_expr
-                  | list_expr'''
-    p[0] = Node('Expression', value=p[1])
+    '''expression : expr_atom
+                  | comparison_expr
+                  | arithmetic_expr'''
+    # 如果是比较表达式或其他复合表达式，则已经是一个Node对象
+    if isinstance(p[1], Node):
+        p[0] = p[1]
+    else:
+        p[0] = Node('Expression', value=p[1])
+
+
+def p_expr_atom(p):
+    '''expr_atom : NUMBER
+                 | STRING
+                 | PLACEHOLDER
+                 | ID
+                 | boolean_expr
+                 | list_expr
+                 | LPAREN expression RPAREN'''
+    if p[1] == '(':
+        # 处理括号表达式，直接返回括号内的表达式节点
+        p[0] = p[2]
+    elif isinstance(p[1], Node):
+        p[0] = p[1]
+    else:
+        p[0] = Node('Expression', value=p[1])
 
 
 def p_boolean_expr(p):
@@ -228,6 +268,65 @@ def p_return_statement(p):
     p[0] = Node('Return', [p[2]])
 
 
+def p_if_statement(p):
+    '''if_statement : IF expression DO statements END
+                   | IF expression DO statements ELSE statements END'''
+    if len(p) == 6:
+        p[0] = Node('IfStatement', [p[2], p[4]], None)
+    else:
+        p[0] = Node('IfStatement', [p[2], p[4], p[6]], None)
+
+
+def p_comparison_expr(p):
+    '''comparison_expr : expr_atom GT expr_atom
+                      | expr_atom LT expr_atom
+                      | expr_atom GE expr_atom
+                      | expr_atom LE expr_atom
+                      | expr_atom EQ expr_atom
+                      | expr_atom NE expr_atom'''
+    
+    # 根据规则索引判断使用的是哪个操作符
+    if p.slice[2].type == 'GT':
+        operator = '>'
+    elif p.slice[2].type == 'LT':
+        operator = '<'
+    elif p.slice[2].type == 'GE':
+        operator = '>='
+    elif p.slice[2].type == 'LE':
+        operator = '<='
+    elif p.slice[2].type == 'EQ':
+        operator = '=='
+    elif p.slice[2].type == 'NE':
+        operator = '!='
+    else:
+        print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
+        operator = None
+    
+    p[0] = Node('ComparisonExpr', [p[1], p[3]], operator)
+
+
+def p_arithmetic_expr(p):
+    '''arithmetic_expr : expression PLUS expression
+                       | expression MINUS expression
+                       | expression TIMES expression
+                       | expression DIVIDE expression'''
+    
+    # 根据规则索引判断使用的是哪个操作符
+    if p.slice[2].type == 'PLUS':
+        operator = '+'
+    elif p.slice[2].type == 'MINUS':
+        operator = '-'
+    elif p.slice[2].type == 'TIMES':
+        operator = '*'
+    elif p.slice[2].type == 'DIVIDE':
+        operator = '/'
+    else:
+        print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
+        operator = None
+    
+    p[0] = Node('ArithmeticExpr', [p[1], p[3]], operator)
+
+
 def p_error(p):
     if p:
         print(