pytest-dsl 0.1.0__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/auth_provider.py

@@ -19,7 +19,7 @@ class AuthProvider(abc.ABC):
     """认证提供者基类"""
     
     @abc.abstractmethod
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """将认证信息应用到请求参数
         
         Args:
@@ -57,6 +57,46 @@ class AuthProvider(abc.ABC):
         request_kwargs.pop('auth', None)
             
         return request_kwargs
+
+    def process_response(self, response: requests.Response) -> None:
+        """处理响应以更新认证状态
+        
+        此方法允许认证提供者在响应返回后处理响应数据，例如从响应中提取
+        CSRF令牌、刷新令牌或其他认证信息，并更新内部状态用于后续请求。
+        
+        Args:
+            response: 请求响应对象
+        """
+        # 默认实现：不做任何处理
+        pass
+    
+    def pre_request_hook(self, method: str, url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """请求发送前的钩子
+        
+        此方法在请求被发送前调用，允许执行额外的请求预处理。
+        
+        Args:
+            method: HTTP方法
+            url: 请求URL
+            request_kwargs: 请求参数字典
+            
+        Returns:
+            更新后的请求参数字典
+        """
+        # 默认实现：不做任何预处理
+        return request_kwargs
+    
+    def post_response_hook(self, response: requests.Response, request_kwargs: Dict[str, Any]) -> None:
+        """响应接收后的钩子
+        
+        此方法在响应被接收后调用，允许执行额外的响应后处理。
+        
+        Args:
+            response: 响应对象
+            request_kwargs: 原始请求参数
+        """
+        # 调用process_response以保持向后兼容
+        self.process_response(response)
     
     @property
     def name(self) -> str:
@@ -77,7 +117,7 @@ class BasicAuthProvider(AuthProvider):
         self.username = username
         self.password = password
         
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """应用基本认证
         
         Args:
@@ -106,7 +146,7 @@ class TokenAuthProvider(AuthProvider):
         self.scheme = scheme
         self.header = header
         
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """应用令牌认证
         
         Args:
@@ -148,7 +188,7 @@ class ApiKeyAuthProvider(AuthProvider):
         self.in_query = in_query
         self.query_param_name = query_param_name or key_name
         
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """应用API Key认证
         
         Args:
@@ -204,7 +244,7 @@ class OAuth2Provider(AuthProvider):
         self._access_token = None
         self._token_expires_at = 0
         
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """应用OAuth2认证
         
         Args:
@@ -272,13 +312,14 @@ class CustomAuthProvider(AuthProvider):
     """自定义认证提供者基类
     
     用户可以通过继承此类并实现apply_auth方法来创建自定义认证提供者。
+    此外，还可以实现process_response方法来处理响应数据，例如提取CSRF令牌。
     """
     def __init__(self):
         """初始化自定义认证提供者"""
         pass
 
     @abc.abstractmethod
-    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    def apply_auth(self, base_url: str, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """应用自定义认证
         
         Args:
@@ -294,7 +335,7 @@ class CustomAuthProvider(AuthProvider):
 auth_provider_registry = {}
 
 
-def register_auth_provider(name: str, provider_class: Type[AuthProvider], *args, **kwargs) -> None:
+def register_auth_provider(name: str, provider_class: Type[AuthProvider]) -> None:
     """注册认证提供者
     
     Args:
@@ -306,8 +347,7 @@ def register_auth_provider(name: str, provider_class: Type[AuthProvider], *args,
     if not issubclass(provider_class, AuthProvider):
         raise ValueError(f"Provider class must be a subclass of AuthProvider, got {provider_class.__name__}")
     
-    provider = provider_class(*args, **kwargs)
-    auth_provider_registry[name] = provider
+    auth_provider_registry[name] = provider_class
     logger.info(f"Registered auth provider '{name}' with class {provider_class.__name__}")
 
 
@@ -399,7 +439,7 @@ def create_auth_provider(auth_config: Dict[str, Any]) -> Optional[AuthProvider]:
     elif auth_type == "custom":
         provider_name = auth_config.get("provider_name")
         if provider_name and provider_name in auth_provider_registry:
-            return auth_provider_registry[provider_name]
+            return auth_provider_registry[provider_name](**auth_config)
         else:
             logger.error(f"未找到名为'{provider_name}'的自定义认证提供者")
             return None

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_client.py

@@ -1,13 +1,10 @@
-import os
 import json
-import time
 import logging
-from typing import Dict, List, Any, Optional, Union, Tuple
+from typing import Dict, Any 
 import requests
-from requests.exceptions import RequestException
 from urllib.parse import urljoin
 from pytest_dsl.core.yaml_vars import yaml_vars
-from pytest_dsl.core.auth_provider import AuthProvider, create_auth_provider
+from pytest_dsl.core.auth_provider import create_auth_provider
 
 logger = logging.getLogger(__name__)
 
@@ -125,11 +122,15 @@ class HTTPClient:
                 
         elif self.auth_provider and 'auth' not in request_kwargs:
             # 应用认证提供者
-            request_kwargs = self.auth_provider.apply_auth(request_kwargs)
+            request_kwargs = self.auth_provider.apply_auth(self.base_url, request_kwargs)
             # 如果使用会话，更新会话头
             if self.use_session and 'headers' in request_kwargs:
                 self._session.headers.update(request_kwargs['headers'])
 
+        # 调用认证提供者的请求前钩子
+        if self.auth_provider and not disable_auth:
+            request_kwargs = self.auth_provider.pre_request_hook(method, url, request_kwargs)
+
         # 记录请求详情
         logger.debug(f"=== HTTP请求详情 ===")
         logger.debug(f"方法: {method}")
@@ -186,6 +187,10 @@ class HTTPClient:
             if not hasattr(response, 'elapsed_ms'):
                 response.elapsed_ms = response.elapsed.total_seconds() * 1000
                 
+            # 调用认证提供者的响应处理钩子
+            if self.auth_provider and not disable_auth:
+                self.auth_provider.post_response_hook(response, request_kwargs)
+                
             return response
         except requests.exceptions.RequestException as e:
             logger.error(f"HTTP请求异常: {type(e).__name__}: {str(e)}")