Penghias Parameter Ditaip Python dalam Automasi Ujian

Mekanisme penghias Python, digabungkan dengan keupayaan pembayang jenis moden, meningkatkan automasi ujian dengan ketara. Gabungan hebat ini, memanfaatkan fleksibiliti Python dan keselamatan jenis modul typing, menghasilkan suite ujian yang lebih mudah diselenggara, boleh dibaca dan teguh. Artikel ini meneroka teknik lanjutan, memfokuskan pada aplikasinya dalam rangka kerja automasi ujian.

Memanfaatkan typing Penambahbaikan Modul

Modul typing telah mengalami peningkatan yang ketara:

• PEP 585: Sokongan asli untuk jenis generik dalam koleksi standard meminimumkan pergantungan pada modul typing untuk jenis biasa.
• PEP 604: Operator | memudahkan anotasi jenis Union.
• PEP 647: TypeAlias menjelaskan definisi alias jenis.
• PEP 649: Penilaian anotasi tertunda mempercepatkan permulaan untuk projek besar.

Penghias Berparameter Ditaip Bangunan

Berikut ialah cara mencipta penghias menggunakan ciri menaip yang dikemas kini ini:

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

Penghias ini menggunakan Protocol untuk menentukan struktur fungsi ujian, meningkatkan fleksibiliti untuk tandatangan fungsi yang pelbagai dalam rangka kerja ujian.

Memohon Penghias untuk Menguji Automasi

Mari kita periksa cara penghias ini meningkatkan automasi ujian:

1. Ujian Khusus Platform menggunakan 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 memastikan penyemak jenis mengenali nilai platform yang sah, menjelaskan ujian yang dijalankan pada platform yang mana—penting untuk ujian merentas platform.

2. Penghias Tamat Masa dengan Benang

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

Ini menggunakan benang untuk kefungsian tamat masa yang boleh dipercayai, penting apabila mengawal masa pelaksanaan ujian.

3. Cuba semula Mekanisme dengan Jenis Kesatuan

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

Versi diperhalusi ini menggunakan pembayang jenis komprehensif, pengendalian pengecualian yang mantap dan kelewatan cuba semula yang boleh dikonfigurasikan. Jenis Union membenarkan fleksibiliti dalam menentukan jenis pengecualian.

Kesimpulan

Menyepadukan ciri menaip lanjutan Python ke dalam penghias meningkatkan keselamatan jenis dan kebolehbacaan kod, meningkatkan rangka kerja automasi ujian dengan ketara. Takrif jenis eksplisit memastikan ujian dijalankan di bawah keadaan yang betul, dengan pengendalian ralat yang sesuai dan kekangan prestasi. Ini membawa kepada ujian yang lebih mantap, boleh diselenggara dan cekap, terutamanya berharga dalam persekitaran ujian yang besar, teragih atau berbilang platform.

Atas ialah kandungan terperinci Penghias Parameter Ditaip Python dalam Automasi Ujian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!