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

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):
         """设置当前测试数据集"""
@@ -101,7 +102,7 @@ class DSLExecutor:
             return self.eval_expression(value)
         elif isinstance(value, str):
             # 定义变量引用模式
-            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:
@@ -133,6 +134,9 @@ 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
             
@@ -154,6 +158,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 +328,19 @@ 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)
+
     def execute(self, node):
         """执行AST节点"""
         handlers = {
@@ -315,7 +351,8 @@ 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
         }
         
         handler = handlers.get(node.type)

pytest_dsl/core/http_request.py

@@ -13,7 +13,7 @@ from pytest_dsl.core.http_client import http_client_manager
 
 # 定义支持的比较操作符
 COMPARISON_OPERATORS = {
-    "eq", "neq", "lt", "lte", "gt", "gte", "in", "not_in"
+    "eq", "neq", "lt", "lte", "gt", "gte", "in", "not_in", "matches"
 }
 
 # 定义支持的断言类型
@@ -397,14 +397,14 @@ class HTTPRequest:
                         if extractor_type in ["jsonpath", "body", "header"]:
                             # 当提取器是jsonpath/body/header时，将contains当作断言类型处理
                             assertion_type = assertion[1]
-                            compare_operator = "eq"  # 默认操作符
+                            compare_operator = assertion[1]  # 匹配操作符和断言类型
                         else:
                             # 否则当作操作符处理
                             assertion_type = "value"
                             compare_operator = assertion[1]
                     else:
                         assertion_type = "value"  # 标记为值比较
-                        compare_operator = assertion[1]  # 比较操作符
+                        compare_operator = assertion[1]
                     
                     expected_value = assertion[2]  # 预期值
                 else:
@@ -421,12 +421,12 @@ class HTTPRequest:
                         # 特殊处理类型断言，它确实需要一个值但在这种格式中没有提供
                         if assertion_type == "type":
                             raise ValueError(f"断言类型 'type' 需要预期值(string/number/boolean/array/object/null)，但未提供: {assertion}")
-                        # 如果是不需要值的断言类型，则允许这种格式
+                        # 断言类型作为操作符
                         expected_value = None
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 使用断言类型作为操作符
                     else:
                         expected_value = None
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 存在性断言的操作符就是断言类型本身
             elif len(assertion) == 4:  # 带操作符的断言 ["jsonpath", "$.id", "eq", 1] 或特殊断言 ["jsonpath", "$.type", "type", "string"]
                 extraction_path = assertion[1]
                 
@@ -449,11 +449,11 @@ class HTTPRequest:
                         # 对于长度断言，总是需要有比较操作符和期望值
                         if len(assertion) < 4:
                             raise ValueError(f"长度断言需要提供预期值: {assertion}")
-                        compare_operator = "eq"  # 在这种4元素格式中，使用默认比较操作符eq
+                        compare_operator = "eq"  # 默认使用相等比较
                         expected_value = assertion[3]  # 预期长度值
                     else:
                         # 对于其他特殊断言，使用第四个元素作为期望值
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 使用断言类型作为操作符
                         expected_value = assertion[3]
             else:  # 5个参数，例如 ["jsonpath", "$", "length", "eq", 10]
                 extraction_path = assertion[1]
@@ -647,15 +647,34 @@ class HTTPRequest:
         
         # 执行完所有断言后，如果有失败的断言，抛出异常
         if failed_assertions:
-            if len(failed_assertions) == 1:
-                # 只有一个断言失败时，直接使用该断言的错误消息
-                raise AssertionError(failed_assertions[0][1])
-            else:
-                # 多个断言失败时，汇总所有错误
-                error_summary = f"多个断言失败 ({len(failed_assertions)}/{len(process_asserts)}):\n"
-                for idx, (assertion_idx, error_msg) in enumerate(failed_assertions, 1):
-                    error_summary += f"\n{idx}. 断言 #{assertion_idx+1}: {error_msg.split('断言失败')[0].strip()}"
-                raise AssertionError(error_summary)
+            # 检查是否只收集失败而不抛出异常（由重试机制设置）
+            collect_only = self.config.get('_collect_failed_assertions_only', False)
+            
+            if not collect_only:
+                if len(failed_assertions) == 1:
+                    # 只有一个断言失败时，直接使用该断言的错误消息
+                    raise AssertionError(failed_assertions[0][1])
+                else:
+                    # 多个断言失败时，汇总所有错误
+                    error_summary = f"多个断言失败 ({len(failed_assertions)}/{len(process_asserts)}):\n"
+                    for idx, (assertion_idx, error_msg) in enumerate(failed_assertions, 1):
+                        # 从错误消息中提取关键部分
+                        if "[" in error_msg and "]" in error_msg:
+                            # 尝试提取提取器类型
+                            extractor_type = error_msg.split("[", 1)[1].split("]")[0] if "[" in error_msg else "未知"
+                        else:
+                            extractor_type = "未知"
+                        
+                        # 生成简短的断言标题
+                        assertion_title = f"断言 #{assertion_idx+1} [{extractor_type}]"
+                        
+                        # 添加分隔线使错误更容易辨别
+                        error_summary += f"\n{'-' * 30}\n{idx}. {assertion_title}:\n{'-' * 30}\n{error_msg}"
+                    
+                    # 添加底部分隔线
+                    error_summary += f"\n{'-' * 50}"
+                    
+                    raise AssertionError(error_summary)
         
         # 返回断言结果和需要重试的断言
         return assert_results, failed_retryable_assertions
@@ -716,15 +735,24 @@ class HTTPRequest:
             elif extractor_type == "status":
                 return self.response.status_code
             elif extractor_type == "body":
-                return self.response.text
+                if isinstance(self.response.text, str):
+                    return self.response.text
+                return str(self.response.text)
             elif extractor_type == "response_time":
                 return self.response.elapsed.total_seconds() * 1000
             else:
                 raise ValueError(f"不支持的提取器类型: {extractor_type}")
         except Exception as e:
+            # 记录提取错误
+            error_message = f"提取值失败({extractor_type}, {extraction_path}): {type(e).__name__}: {str(e)}"
+            allure.attach(
+                error_message,
+                name=f"提取错误: {extractor_type}",
+                attachment_type=allure.attachment_type.TEXT
+            )
             if default_value is not None:
                 return default_value
-            raise ValueError(f"提取值失败({extractor_type}, {extraction_path}): {str(e)}")
+            raise ValueError(error_message)
     
     def _extract_jsonpath(self, path: str, default_value: Any = None) -> Any:
         """使用JSONPath从JSON响应提取值
@@ -907,13 +935,87 @@ class HTTPRequest:
                     attachment_type=allure.attachment_type.TEXT
                 )
         
+        # 记录断言参数
+        allure.attach(
+            f"断言类型: {assertion_type}\n"
+            f"比较操作符: {operator}\n"
+            f"实际值: {actual_value} ({type(actual_value).__name__})\n"
+            f"期望值: {expected_value} ({type(expected_value).__name__ if expected_value is not None else 'None'})",
+            name="断言参数",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        
         # 基于断言类型执行断言
         if assertion_type == "value":
             # 直接使用操作符进行比较
             return self._compare_values(actual_value, expected_value, operator)
+        # 特殊断言类型 - 这些类型的操作符与断言类型匹配
+        elif assertion_type in ["contains", "not_contains", "startswith", "endswith", "matches", "schema"]:
+            # 直接使用断言类型作为方法处理，实现特殊断言逻辑
+            if assertion_type == "contains":
+                # contains断言总是检查actual是否包含expected
+                if isinstance(actual_value, str):
+                    return str(expected_value) in actual_value
+                elif isinstance(actual_value, (list, tuple, dict)):
+                    return expected_value in actual_value
+                return False
+            elif assertion_type == "not_contains":
+                # not_contains断言总是检查actual是否不包含expected
+                if isinstance(actual_value, str):
+                    return str(expected_value) not in actual_value
+                elif isinstance(actual_value, (list, tuple, dict)):
+                    return expected_value not in actual_value
+                return True
+            elif assertion_type == "startswith":
+                return isinstance(actual_value, str) and actual_value.startswith(str(expected_value))
+            elif assertion_type == "endswith":
+                return isinstance(actual_value, str) and actual_value.endswith(str(expected_value))
+            elif assertion_type == "matches":
+                if not isinstance(actual_value, str):
+                    actual_value = str(actual_value) if actual_value is not None else ""
+                try:
+                    import re
+                    pattern = str(expected_value)
+                    match_result = bool(re.search(pattern, actual_value))
+                    # 记录匹配结果
+                    allure.attach(
+                        f"正则表达式匹配结果: {'成功' if match_result else '失败'}\n"
+                        f"模式: {pattern}\n"
+                        f"目标字符串: {actual_value}",
+                        name="正则表达式匹配",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return match_result
+                except Exception as e:
+                    # 记录正则表达式匹配错误
+                    allure.attach(
+                        f"正则表达式匹配失败: {type(e).__name__}: {str(e)}\n"
+                        f"模式: {expected_value}\n"
+                        f"目标字符串: {actual_value}",
+                        name="正则表达式错误",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return False
+            elif assertion_type == "schema":
+                try:
+                    from jsonschema import validate
+                    validate(instance=actual_value, schema=expected_value)
+                    return True
+                except Exception as e:
+                    # 记录JSON Schema验证错误
+                    allure.attach(
+                        f"JSON Schema验证失败: {type(e).__name__}: {str(e)}\n"
+                        f"Schema: {expected_value}\n"
+                        f"实例: {actual_value}",
+                        name="Schema验证错误",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return False
         elif assertion_type == "length":
             # 长度比较
-            return self._compare_values(actual_value, expected_value, operator)
+            # 使用实际的比较操作符进行比较，默认使用eq
+            effective_operator = "eq" if operator == "length" else operator
+            return self._compare_values(actual_value, expected_value, effective_operator)
         elif assertion_type == "exists":
             return actual_value is not None
         elif assertion_type == "not_exists":
@@ -932,40 +1034,6 @@ class HTTPRequest:
             elif expected_value == "null":
                 return actual_value is None
             return False
-        elif assertion_type == "contains":
-            # contains断言总是检查actual是否包含expected
-            if isinstance(actual_value, str):
-                return str(expected_value) in actual_value
-            elif isinstance(actual_value, (list, tuple, dict)):
-                return expected_value in actual_value
-            return False
-        elif assertion_type == "not_contains":
-            # not_contains断言总是检查actual是否不包含expected
-            if isinstance(actual_value, str):
-                return str(expected_value) not in actual_value
-            elif isinstance(actual_value, (list, tuple, dict)):
-                return expected_value not in actual_value
-            return True
-        elif assertion_type == "startswith":
-            return isinstance(actual_value, str) and actual_value.startswith(str(expected_value))
-        elif assertion_type == "endswith":
-            return isinstance(actual_value, str) and actual_value.endswith(str(expected_value))
-        elif assertion_type == "matches":
-            if not isinstance(actual_value, str):
-                return False
-            try:
-                import re
-                pattern = str(expected_value)
-                return bool(re.search(pattern, actual_value))
-            except:
-                return False
-        elif assertion_type == "schema":
-            try:
-                from jsonschema import validate
-                validate(instance=actual_value, schema=expected_value)
-                return True
-            except:
-                return False
         else:
             raise ValueError(f"不支持的断言类型: {assertion_type}")
             
@@ -998,6 +1066,47 @@ class HTTPRequest:
         elif operator == "not_in":
             # not_in操作符检查actual是否不在expected列表中
             return actual_value not in expected_value
+        elif operator == "contains":
+            # contains操作符检查actual是否包含expected
+            if isinstance(actual_value, str):
+                return str(expected_value) in actual_value
+            elif isinstance(actual_value, (list, tuple, dict)):
+                return expected_value in actual_value
+            return False
+        elif operator == "not_contains":
+            # not_contains操作符检查actual是否不包含expected
+            if isinstance(actual_value, str):
+                return str(expected_value) not in actual_value
+            elif isinstance(actual_value, (list, tuple, dict)):
+                return expected_value not in actual_value
+            return True
+        elif operator == "matches":
+            # matches操作符使用正则表达式进行匹配
+            if not isinstance(actual_value, str):
+                actual_value = str(actual_value) if actual_value is not None else ""
+            try:
+                import re
+                pattern = str(expected_value)
+                match_result = bool(re.search(pattern, actual_value))
+                # 记录匹配结果
+                allure.attach(
+                    f"正则表达式匹配结果: {'成功' if match_result else '失败'}\n"
+                    f"模式: {pattern}\n"
+                    f"目标字符串: {actual_value}",
+                    name="正则表达式匹配",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                return match_result
+            except Exception as e:
+                # 记录正则表达式匹配错误
+                allure.attach(
+                    f"正则表达式匹配失败: {type(e).__name__}: {str(e)}\n"
+                    f"模式: {expected_value}\n"
+                    f"目标字符串: {actual_value}",
+                    name="正则表达式错误",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                return False
         else:
             raise ValueError(f"不支持的比较操作符: {operator}")
     

pytest_dsl/core/lexer.py

@@ -9,7 +9,8 @@ reserved = {
     'range': 'RANGE',
     'using': 'USING',  # Add new keyword for data-driven testing
     'True': 'TRUE',    # 添加布尔值支持
-    'False': 'FALSE'   # 添加布尔值支持
+    'False': 'FALSE',   # 添加布尔值支持
+    'return': 'RETURN'  # 添加return关键字支持
 }
 
 # token 名称列表
@@ -33,6 +34,8 @@ tokens = [
     'DATE_KEYWORD',
     'TEARDOWN_KEYWORD',
     'DATA_KEYWORD',  # Add new token for @data keyword
+    'KEYWORD_KEYWORD',  # 添加@keyword关键字
+    'IMPORT_KEYWORD',   # 添加@import关键字
 ] + list(reserved.values())
 
 # 正则表达式定义 token
@@ -106,6 +109,16 @@ def t_DATA_KEYWORD(t):
     return t
 
 
+def t_KEYWORD_KEYWORD(t):
+    r'@keyword'
+    return t
+
+
+def t_IMPORT_KEYWORD(t):
+    r'@import'
+    return t
+
+
 def t_NUMBER(t):
     r'\d+'
     t.value = int(t.value)