Decorators in Python provide a powerful mechanism for modifying or enhancing function behavior without altering the original code. This feature proves particularly valuable in test automation scenarios where common functionality needs to be shared across multiple test cases.

A decorator is essentially a higher-order function that takes another function as input and returns a modified version of that function. Python uses the @decorator_name syntax to apply decorators to functions.

Basic Decorator Implementation

def logging_wrapper(original_func):
    def enhanced_function():
        print("Executing pre-function operations")
        original_func()
        print("Executing post-function operations")
    return enhanced_function

@logging_wrapper
def greet_user():
    print("Welcome!")

greet_user()

In this implementation, logging_wrapper serves as the decorator function that accepts original_func as its parameter. The enhanced_function adds supplementary behavior before and after calling the original function. When greet_user() is invoked, it actually executes the wrapped version returned by the decorator.

Output:

Executing pre-function operations
Welcome!
Executing post-function operations

Parameteirzed Decorators

Decorators can also accept parametres by implementing an additional layer of function wrapping:

def execute_multiple(count):
    def outer_decorator(target_func):
        def inner_wrapper():
            for iteration in range(count):
                target_func()
        return inner_wrapper
    return outer_decorator

@execute_multiple(count=4)
def display_message():
    print("Processing...")

display_message()

Output:

Processing...
Processing...
Processing...
Processing...

Preserving Function Metadata with functools.wraps

The functools module provides the wraps decorator to maintain the original function's metadata such as __name__, __doc__, and other attributes:

from functools import wraps

def monitoring_decorator(wrapped_func):
    @wraps(wrapped_func)
    def execution_wrapper():
        print("Starting function execution")
        wrapped_func()
        print("Completing function execution")
    return execution_wrapper

@monitoring_decorator
def sample_operation():
    """Perform a sample operation."""
    print("Operation executed")

sample_operation()
print(sample_operation.__name__)
print(sample_operation.__doc__)

Output:

Starting function execution
Operation executed
Completing function execution
sample_operation
Perform a sample operation.

These decorator patterns can be integrated into custom test automation frameworks to encapsulate common functionality and improve code reusability across test suites.