테스트 자동화의 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 중국어 웹사이트의 기타 관련 기사를 참조하세요!