pytest-dsl 0.1.0__py3-none-any.whl

pytest_dsl/__init__.py

@@ -0,0 +1,10 @@
+"""
+pytest-dsl - 基于pytest的DSL测试框架
+
+使用自定义的领域特定语言(DSL)来编写测试用例，使测试更加直观、易读和易维护。
+"""
+
+__version__ = "0.1.0" 
+
+# 导出 auto_dsl 装饰器，使其可以直接从包导入
+from pytest_dsl.core.auto_decorator import auto_dsl

pytest_dsl/cli.py

@@ -0,0 +1,44 @@
+"""
+pytest-dsl命令行入口
+
+提供独立的命令行工具，用于执行DSL文件。
+"""
+
+import sys
+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
+
+
+def read_file(filename):
+    """读取 DSL 文件内容"""
+    with open(filename, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+def main():
+    """命令行入口点"""
+    if len(sys.argv) < 2:
+        print("用法: python -m pytest_dsl.cli <dsl_file>")
+        sys.exit(1)
+        
+    filename = sys.argv[1]
+    
+    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}")
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main() 

pytest_dsl/conftest_adapter.py

@@ -0,0 +1,4 @@
+# 这是一个适配原有conftest的文件，重定向到新的插件入口
+# 保留此文件是为了向后兼容
+
+from pytest_dsl.plugin import *

pytest_dsl/core/auth_provider.py

@@ -0,0 +1,409 @@
+"""认证提供者模块
+
+该模块提供了用于HTTP请求认证的接口和实现。
+"""
+
+import abc
+import base64
+import json
+import logging
+import time
+from typing import Dict, Any, Optional, Callable, Union, Tuple, Type
+import requests
+from requests.auth import HTTPBasicAuth
+
+logger = logging.getLogger(__name__)
+
+
+class AuthProvider(abc.ABC):
+    """认证提供者基类"""
+    
+    @abc.abstractmethod
+    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """将认证信息应用到请求参数
+        
+        Args:
+            request_kwargs: 请求参数字典
+            
+        Returns:
+            更新后的请求参数字典
+        """
+        pass
+    
+    def clean_auth_state(self, request_kwargs: Dict[str, Any] = None) -> Dict[str, Any]:
+        """清理认证状态
+        
+        此方法用于清理认证状态，例如移除认证头、清空会话Cookie等。
+        子类可以覆盖此方法以提供自定义的清理逻辑。
+        
+        Args:
+            request_kwargs: 请求参数字典
+            
+        Returns:
+            更新后的请求参数字典
+        """
+        # 默认实现：移除基本的认证头
+        if request_kwargs is None:
+            return {}
+            
+        if "headers" in request_kwargs:
+            auth_headers = [
+                'Authorization', 'X-API-Key', 'X-Api-Key', 'api-key', 'Api-Key',
+            ]
+            for header in auth_headers:
+                request_kwargs["headers"].pop(header, None)
+                
+        # 移除认证参数
+        request_kwargs.pop('auth', None)
+            
+        return request_kwargs
+    
+    @property
+    def name(self) -> str:
+        """返回认证提供者名称"""
+        return self.__class__.__name__
+
+
+class BasicAuthProvider(AuthProvider):
+    """基本认证提供者"""
+    
+    def __init__(self, username: str, password: str):
+        """初始化基本认证
+        
+        Args:
+            username: 用户名
+            password: 密码
+        """
+        self.username = username
+        self.password = password
+        
+    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """应用基本认证
+        
+        Args:
+            request_kwargs: 请求参数
+            
+        Returns:
+            更新后的请求参数
+        """
+        # 使用requests的基本认证
+        request_kwargs["auth"] = HTTPBasicAuth(self.username, self.password)
+        return request_kwargs
+
+
+class TokenAuthProvider(AuthProvider):
+    """令牌认证提供者"""
+    
+    def __init__(self, token: str, scheme: str = "Bearer", header: str = "Authorization"):
+        """初始化令牌认证
+        
+        Args:
+            token: 认证令牌
+            scheme: 认证方案 (例如 "Bearer")
+            header: 认证头名称 (默认为 "Authorization")
+        """
+        self.token = token
+        self.scheme = scheme
+        self.header = header
+        
+    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """应用令牌认证
+        
+        Args:
+            request_kwargs: 请求参数
+            
+        Returns:
+            更新后的请求参数
+        """
+        # 确保headers存在
+        if "headers" not in request_kwargs:
+            request_kwargs["headers"] = {}
+            
+        # 添加认证头
+        if self.scheme:
+            request_kwargs["headers"][self.header] = f"{self.scheme} {self.token}"
+        else:
+            request_kwargs["headers"][self.header] = self.token
+            
+        return request_kwargs
+
+
+class ApiKeyAuthProvider(AuthProvider):
+    """API Key认证提供者"""
+    
+    def __init__(self, api_key: str, key_name: str = "X-API-Key", in_header: bool = True, 
+                 in_query: bool = False, query_param_name: str = None):
+        """初始化API Key认证
+        
+        Args:
+            api_key: API密钥
+            key_name: 密钥名称 (默认为 "X-API-Key")
+            in_header: 是否在请求头中添加密钥
+            in_query: 是否在查询参数中添加密钥
+            query_param_name: 查询参数名称 (如果与header名称不同)
+        """
+        self.api_key = api_key
+        self.key_name = key_name
+        self.in_header = in_header
+        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]:
+        """应用API Key认证
+        
+        Args:
+            request_kwargs: 请求参数
+            
+        Returns:
+            更新后的请求参数
+        """
+        # 添加到请求头
+        if self.in_header:
+            if "headers" not in request_kwargs:
+                request_kwargs["headers"] = {}
+            request_kwargs["headers"][self.key_name] = self.api_key
+            
+        # 添加到查询参数
+        if self.in_query:
+            if "params" not in request_kwargs:
+                request_kwargs["params"] = {}
+            request_kwargs["params"][self.query_param_name] = self.api_key
+            
+        return request_kwargs
+
+
+class OAuth2Provider(AuthProvider):
+    """OAuth2认证提供者"""
+    
+    def __init__(self, token_url: str, client_id: str, client_secret: str, 
+                 scope: str = None, grant_type: str = "client_credentials",
+                 username: str = None, password: str = None,
+                 token_refresh_window: int = 60):
+        """初始化OAuth2认证
+        
+        Args:
+            token_url: 获取令牌的URL
+            client_id: 客户端ID
+            client_secret: 客户端密钥
+            scope: 权限范围
+            grant_type: 授权类型 (默认为 "client_credentials")
+            username: 用户名 (如果grant_type为"password")
+            password: 密码 (如果grant_type为"password")
+            token_refresh_window: 令牌刷新窗口 (秒)，在令牌过期前多少秒刷新
+        """
+        self.token_url = token_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scope = scope
+        self.grant_type = grant_type
+        self.username = username
+        self.password = password
+        self.token_refresh_window = token_refresh_window
+        
+        # 令牌缓存
+        self._access_token = None
+        self._token_expires_at = 0
+        
+    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """应用OAuth2认证
+        
+        Args:
+            request_kwargs: 请求参数
+            
+        Returns:
+            更新后的请求参数
+        """
+        # 确保有有效的令牌
+        self._ensure_valid_token()
+        
+        # 确保headers存在
+        if "headers" not in request_kwargs:
+            request_kwargs["headers"] = {}
+            
+        # 添加认证头
+        request_kwargs["headers"]["Authorization"] = f"Bearer {self._access_token}"
+        return request_kwargs
+        
+    def _ensure_valid_token(self) -> None:
+        """确保有有效的访问令牌"""
+        current_time = time.time()
+        
+        # 如果令牌不存在或即将过期，刷新令牌
+        if not self._access_token or current_time + self.token_refresh_window >= self._token_expires_at:
+            self._refresh_token()
+            
+    def _refresh_token(self) -> None:
+        """刷新OAuth2令牌"""
+        data = {
+            "grant_type": self.grant_type,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret
+        }
+        
+        if self.scope:
+            data["scope"] = self.scope
+            
+        # 对于密码模式
+        if self.grant_type == "password" and self.username and self.password:
+            data["username"] = self.username
+            data["password"] = self.password
+            
+        try:
+            response = requests.post(self.token_url, data=data)
+            response.raise_for_status()
+            
+            token_data = response.json()
+            self._access_token = token_data.get("access_token")
+            expires_in = token_data.get("expires_in", 3600)  # 默认1小时
+            
+            if not self._access_token:
+                raise ValueError("响应中缺少access_token字段")
+                
+            # 计算过期时间
+            self._token_expires_at = time.time() + expires_in
+            logger.info(f"成功获取OAuth2令牌，有效期{expires_in}秒")
+            
+        except Exception as e:
+            logger.error(f"获取OAuth2令牌失败: {str(e)}")
+            raise
+
+
+class CustomAuthProvider(AuthProvider):
+    """自定义认证提供者基类
+    
+    用户可以通过继承此类并实现apply_auth方法来创建自定义认证提供者。
+    """
+    def __init__(self):
+        """初始化自定义认证提供者"""
+        pass
+
+    @abc.abstractmethod
+    def apply_auth(self, request_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """应用自定义认证
+        
+        Args:
+            request_kwargs: 请求参数
+            
+        Returns:
+            更新后的请求参数
+        """
+        pass
+
+
+# 认证提供者注册表
+auth_provider_registry = {}
+
+
+def register_auth_provider(name: str, provider_class: Type[AuthProvider], *args, **kwargs) -> None:
+    """注册认证提供者
+    
+    Args:
+        name: 提供者名称
+        provider_class: 提供者类，必须是 AuthProvider 的子类
+        *args: 传递给提供者类的初始化参数
+        **kwargs: 传递给提供者类的初始化关键字参数
+    """
+    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
+    logger.info(f"Registered auth provider '{name}' with class {provider_class.__name__}")
+
+
+def get_auth_provider(name: str) -> Optional[AuthProvider]:
+    """获取认证提供者
+    
+    Args:
+        name: 提供者名称
+        
+    Returns:
+        认证提供者实例
+    """
+    return auth_provider_registry.get(name)
+
+
+def create_auth_provider(auth_config: Dict[str, Any]) -> Optional[AuthProvider]:
+    """根据配置创建认证提供者
+    
+    Args:
+        auth_config: 认证配置
+        
+    Returns:
+        认证提供者实例
+    """
+    auth_type = auth_config.get("type", "").lower()
+    
+    if not auth_type:
+        return None
+        
+    if auth_type == "basic":
+        username = auth_config.get("username")
+        password = auth_config.get("password")
+        
+        if not username or not password:
+            logger.error("基本认证配置缺少username或password参数")
+            return None
+            
+        return BasicAuthProvider(username, password)
+        
+    elif auth_type == "token":
+        token = auth_config.get("token")
+        scheme = auth_config.get("scheme", "Bearer")
+        header = auth_config.get("header", "Authorization")
+        
+        if not token:
+            logger.error("令牌认证配置缺少token参数")
+            return None
+            
+        return TokenAuthProvider(token, scheme, header)
+        
+    elif auth_type == "api_key":
+        api_key = auth_config.get("api_key")
+        key_name = auth_config.get("key_name", "X-API-Key")
+        in_header = auth_config.get("in_header", True)
+        in_query = auth_config.get("in_query", False)
+        query_param_name = auth_config.get("query_param_name")
+        
+        if not api_key:
+            logger.error("API Key认证配置缺少api_key参数")
+            return None
+            
+        return ApiKeyAuthProvider(
+            api_key=api_key,
+            key_name=key_name,
+            in_header=in_header,
+            in_query=in_query,
+            query_param_name=query_param_name
+        )
+        
+    elif auth_type == "oauth2":
+        token_url = auth_config.get("token_url")
+        client_id = auth_config.get("client_id")
+        client_secret = auth_config.get("client_secret")
+        scope = auth_config.get("scope")
+        grant_type = auth_config.get("grant_type", "client_credentials")
+        username = auth_config.get("username")
+        password = auth_config.get("password")
+        token_refresh_window = auth_config.get("token_refresh_window", 60)
+        
+        if not token_url or not client_id or not client_secret:
+            logger.error("OAuth2认证配置缺少必要参数")
+            return None
+            
+        return OAuth2Provider(
+            token_url, client_id, client_secret, scope, grant_type,
+            username, password, token_refresh_window
+        )
+        
+    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]
+        else:
+            logger.error(f"未找到名为'{provider_name}'的自定义认证提供者")
+            return None
+        
+    else:
+        logger.error(f"不支持的认证类型: {auth_type}")
+        return None 

pytest_dsl/core/auto_decorator.py

@@ -0,0 +1,181 @@
+"""自动测试装饰器模块
+
+该模块提供装饰器功能，用于将指定目录下的.auto文件动态添加为测试方法到被装饰的类中。
+这种方式更贴合pytest的设计理念，可以充分利用pytest的fixture、参数化等功能。
+"""
+
+import os
+import inspect
+import functools
+from pathlib import Path
+import pytest
+from typing import Optional, Union, List, Dict, Any, Callable, Type
+
+from pytest_dsl.core.dsl_executor import DSLExecutor
+from pytest_dsl.core.dsl_executor_utils import read_file, execute_dsl_file, extract_metadata_from_ast
+from pytest_dsl.core.lexer import get_lexer
+from pytest_dsl.core.parser import get_parser
+from pytest_dsl.core.auto_directory import SETUP_FILE_NAME, TEARDOWN_FILE_NAME, execute_hook_file
+
+# 获取词法分析器和解析器实例
+lexer = get_lexer()
+parser = get_parser()
+
+
+def auto_dsl(directory: Union[str, Path], is_file: bool = False):
+    """
+    装饰器函数，用于将指定目录下的.auto文件动态添加为测试方法到被装饰的类中。
+    
+    Args:
+        directory: 包含.auto文件的目录路径，可以是相对路径或绝对路径
+        is_file: 是否是文件路径而不是目录路径
+        
+    Returns:
+        装饰器函数
+    """
+    path = Path(directory)
+    if not path.is_absolute():
+        # 如果是相对路径，则相对于调用者的文件位置
+        caller_frame = inspect.currentframe().f_back
+        caller_file = caller_frame.f_globals['__file__']
+        caller_dir = Path(caller_file).parent
+        path = (caller_dir / path).resolve()
+    
+    if is_file:
+        # 路径是文件
+        if not path.exists() or not path.is_file():
+            raise ValueError(f"文件不存在或不是有效文件: {path}")
+        file_path = path
+    else:
+        # 路径是目录
+        if not path.exists() or not path.is_dir():
+            raise ValueError(f"目录不存在或不是有效目录: {path}")
+        directory_path = path
+    
+    def decorator(cls):
+        if is_file:
+            # 如果是文件路径，只添加这个文件的测试方法
+            _add_test_method(cls, file_path)
+        else:
+            # 检查setup.auto和teardown.auto文件
+            setup_file = directory_path / SETUP_FILE_NAME
+            teardown_file = directory_path / TEARDOWN_FILE_NAME
+            
+            # 添加setup和teardown方法
+            if setup_file.exists():
+                @classmethod
+                @pytest.fixture(scope="class", autouse=True)
+                def setup_class(cls, request):
+                    execute_hook_file(setup_file, True, str(directory_path))
+                    
+                setattr(cls, "setup_class", setup_class)
+            
+            if teardown_file.exists():
+                @classmethod
+                @pytest.fixture(scope="class", autouse=True)
+                def teardown_class(cls, request):
+                    request.addfinalizer(lambda: execute_hook_file(teardown_file, False, str(directory_path)))
+                    
+                setattr(cls, "teardown_class", teardown_class)
+            
+            # 处理目录中的测试文件
+            for auto_file in directory_path.glob("*.auto"):
+                if auto_file.name not in [SETUP_FILE_NAME, TEARDOWN_FILE_NAME]:
+                    _add_test_method(cls, auto_file)
+        
+        return cls
+    
+    return decorator
+
+
+def _add_test_method(cls: Type, auto_file: Path) -> None:
+    """
+    为.auto文件创建测试方法并添加到类中
+    
+    Args:
+        cls: 要添加测试方法的类
+        auto_file: .auto文件路径
+    """
+    test_name = f"test_{auto_file.stem}"
+    
+    # 读取DSL文件内容并解析
+    dsl_code = read_file(str(auto_file))
+    ast = parser.parse(dsl_code, lexer=lexer)
+    
+    # 检查是否有数据驱动标记和测试名称
+    data_source, test_title = extract_metadata_from_ast(ast)
+    
+    if data_source:
+        test_method = _create_data_driven_test(auto_file, data_source, test_title)
+    else:
+        test_method = _create_simple_test(auto_file)
+    
+    # 将测试方法添加到类
+    setattr(cls, test_name, test_method)
+
+
+def _create_simple_test(auto_file: Path) -> Callable:
+    """
+    创建普通的测试方法
+    
+    Args:
+        auto_file: .auto文件路径
+        
+    Returns:
+        function: 测试方法
+    """
+    def test_method(self):
+        execute_dsl_file(str(auto_file))
+    
+    return test_method
+
+
+def _create_data_driven_test(auto_file: Path, data_source: Dict, test_title: Optional[str]) -> Callable:
+    """
+    创建数据驱动的测试方法
+    
+    Args:
+        auto_file: .auto文件路径
+        data_source: 数据源
+        test_title: 测试标题
+        
+    Returns:
+        function: 装饰后的测试方法
+    """
+    def test_method(self, test_data):
+        executor = DSLExecutor()
+        executor.set_current_data(test_data)
+        execute_dsl_file(str(auto_file), executor)
+    
+    # 加载测试数据
+    executor = DSLExecutor()
+    test_data_list = executor._load_test_data(data_source)
+    
+    # 为每个数据集创建一个唯一的ID
+    test_ids = _generate_test_ids(test_data_list, test_title or auto_file.stem)
+    
+    # 使用pytest.mark.parametrize装饰测试方法
+    return pytest.mark.parametrize(
+        'test_data',
+        test_data_list,
+        ids=test_ids
+    )(test_method)
+
+
+def _generate_test_ids(test_data_list: List[Dict[str, Any]], base_name: str) -> List[str]:
+    """
+    为数据驱动测试生成ID
+    
+    Args:
+        test_data_list: 测试数据列表
+        base_name: 基础名称
+        
+    Returns:
+        List[str]: 测试ID列表
+    """
+    test_ids = []
+    for data in test_data_list:
+        # 创建一个可读的测试ID
+        test_id = f"{base_name}-{'-'.join(f'{k}={v}' for k, v in data.items())}"
+        test_ids.append(test_id)
+    return test_ids