测试自动化中的 Python 类型参数化装饰器

Python 的装饰器机制与现代类型提示功能相结合，显着提高了测试自动化。 这种强大的组合利用了 Python 的灵活性和 typing 模块的类型安全性，产生了更可维护、可读和健壮的测试套件。本文探讨了先进技术，重点关注它们在测试自动化框架中的应用。

利用 typing 模块的增强功能

typing模块进行了重大改进：

• PEP 585： 对标准集合中泛型类型的本机支持最大限度地减少了对常见类型的 typing 模块的依赖。
• PEP 604： | 运算符简化了 Union 类型注释。
• PEP 647： TypeAlias 澄清类型别名定义。
• PEP 649：延迟注释评估可加快大型项目的启动速度。

构建类型参数化装饰器

以下是如何使用这些更新的输入功能创建装饰器：

from typing import Protocol, TypeVar, Generic, Callable, Any
from functools import wraps

# TypeVar for generic typing
T = TypeVar('T')

# Protocol for defining function structure
class TestProtocol(Protocol):
    def __call__(self, *args: Any, **kwargs: Any) -> Any:
        ...

def generic_decorator(param: str) -> Callable[[Callable[..., T]], Callable[..., T]]:
    """
    Generic decorator for functions returning type T.

    Args:
        param:  A string parameter.

    Returns:
        A callable wrapping the original function.
    """
    def decorator(func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)  # Preserves original function metadata
        def wrapper(*args: Any, **kwargs: Any) -> T:
            print(f"Decorator with param: {param}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@generic_decorator("test_param")
def test_function(x: int) -> int:
    """Returns input multiplied by 2."""
    return x * 2

该装饰器使用 Protocol 来定义测试函数的结构，提高测试框架中不同函数签名的灵活性。

将装饰器应用于测试自动化

让我们看看这些装饰器如何增强测试自动化：

1。使用 Literal

进行特定于平台的测试

from typing import Literal, Callable, Any
import sys

def run_only_on(platform: Literal["linux", "darwin", "win32"]) -> Callable:
    """
    Runs a test only on the specified platform.

    Args:
        platform: Target platform.

    Returns:
        A callable wrapping the test function.
    """
    def decorator(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            if sys.platform == platform:
                return func(*args, **kwargs)
            print(f"Skipping test on platform: {sys.platform}")
            return None
        return wrapper
    return decorator

@run_only_on("linux")
def test_linux_feature() -> None:
    """Linux-specific test."""
    pass

Literal 确保类型检查器识别有效的 platform 值，明确哪些测试在哪些平台上运行——这对于跨平台测试至关重要。

2。带线程的超时装饰器

from typing import Callable, Any, Optional
import threading
import time
from concurrent.futures import ThreadPoolExecutor, TimeoutError

def timeout(seconds: int) -> Callable:
    """
    Enforces a timeout on test functions.

    Args:
        seconds: Maximum execution time.

    Returns:
        A callable wrapping the function with timeout logic.
    """
    def decorator(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Optional[Any]:
            with ThreadPoolExecutor(max_workers=1) as executor:
                future = executor.submit(func, *args, **kwargs)
                try:
                    return future.result(timeout=seconds)
                except TimeoutError:
                    print(f"Function {func.__name__} timed out after {seconds} seconds")
                    return None
        return wrapper
    return decorator

@timeout(5)
def test_long_running_operation() -> None:
    """Test that times out if it takes too long."""
    time.sleep(10)  # Triggers timeout

这使用线程来实现可靠的超时功能，这在控制测试执行时间时至关重要。

3。联合类型的重试机制

from typing import Callable, Any, Union, Type, Tuple, Optional
import time

def retry_on_exception(
    exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]], 
    attempts: int = 3,
    delay: float = 1.0
) -> Callable:
    """
    Retries a function on specified exceptions.

    Args:
        exceptions: Exception type(s) to catch.
        attempts: Maximum retry attempts.
        delay: Delay between attempts.

    Returns:
        A callable wrapping the function with retry logic.
    """
    def decorator(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            last_exception: Optional[Exception] = None
            for attempt in range(attempts):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last_exception = e
                    print(f"Attempt {attempt + 1} failed with {type(e).__name__}: {str(e)}")
                    time.sleep(delay)
            if last_exception:
                raise last_exception
        return wrapper
    return decorator

@retry_on_exception(Exception, attempts=5)
def test_network_connection() -> None:
    """Test network connection with retry logic."""
    pass

这个改进的版本使用全面的类型提示、强大的异常处理和可配置的重试延迟。 Union 类型允许灵活地指定异常类型。

结论

将 Python 的高级类型功能集成到装饰器中可以提高类型安全性和代码可读性，从而显着增强测试自动化框架。 显式类型定义确保测试在正确的条件下运行，并具有适当的错误处理和性能约束。这会带来更健壮、可维护和高效的测试，在大型、分布式或多平台测试环境中尤其有价值。

以上是测试自动化中的 Python 类型参数化装饰器的详细内容。更多信息请关注PHP中文网其他相关文章！