Décorateurs paramétrés typés Python dans l'automatisation des tests

Le mécanisme de décoration de Python, combiné à des capacités modernes d'indication de type, améliore considérablement l'automatisation des tests. Cette combinaison puissante, tirant parti de la flexibilité de Python et de la sécurité de type du module typing, donne lieu à des suites de tests plus maintenables, plus lisibles et plus robustes. Cet article explore les techniques avancées, en se concentrant sur leur application dans les cadres d'automatisation des tests.

Tirer parti des améliorations du module typing

Le module typing a subi des améliorations significatives :

• PEP 585 : La prise en charge native des types génériques dans les collections standard minimise la dépendance à l'égard du module typing pour les types courants.
• PEP 604 : L'opérateur | simplifie les annotations de type Union.
• PEP 647 : TypeAlias clarifie les définitions des alias de type.
• PEP 649 : L'évaluation différée des annotations accélère le démarrage des grands projets.

Décorateurs paramétrés typés bâtiment

Voici comment créer un décorateur à l'aide de ces fonctionnalités de saisie mises à jour :

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

Ce décorateur utilise Protocol pour définir la structure d'une fonction de test, augmentant ainsi la flexibilité pour diverses signatures de fonction dans les frameworks de test.

Application de décorateurs à l'automatisation des tests

Examinons comment ces décorateurs améliorent l'automatisation des tests :

1. Tests spécifiques à la plate-forme utilisant 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 garantit que les vérificateurs de type reconnaissent les valeurs platform valides, clarifiant ainsi quels tests s'exécutent sur quelles plates-formes, ce qui est crucial pour les tests multiplateformes.

2. Décorateurs de délai d'attente avec Threading

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

Cela utilise le threading pour une fonctionnalité de délai d'attente fiable, essentielle pour contrôler le temps d'exécution des tests.

3. Mécanisme de nouvelle tentative avec types d'union

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

Cette version raffinée utilise des astuces de type complètes, une gestion robuste des exceptions et un délai de nouvelle tentative configurable. Les types Union permettent une certaine flexibilité dans la spécification des types d'exception.

Conclusion

L'intégration des fonctionnalités de saisie avancées de Python dans les décorateurs améliore à la fois la sécurité des types et la lisibilité du code, améliorant ainsi considérablement les cadres d'automatisation des tests. Les définitions de types explicites garantissent que les tests s'exécutent dans des conditions correctes, avec une gestion des erreurs et des contraintes de performances appropriées. Cela conduit à des tests plus robustes, maintenables et efficaces, particulièrement précieux dans les environnements de test vastes, distribués ou multiplateformes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!