Python decorators can be very useful in testing to add functionality to your test functions or methods. Decorators can help with tasks such as setting up and tearing down test fixtures, handling exceptions, logging, and more. Here are some common use cases for decorators in testing:

Setup and Teardown: Decorators can be used to define setup and teardown actions for test functions or methods. For example:

def setup_teardown(func):
    def wrapper():
        # Setup
        print("Setup...")
        func()
        # Teardown
        print("Teardown...")
    return wrapper

@setup_teardown
def test_example():
    print("Running test...")
    # Test logic here

test_example()

Logging: Decorators can add logging functionality to test functions to log information about the test execution:

def log_test(func):
def wrapper(*args, *kwargs): print(f"Running test: {func.name}") result = func(args, **kwargs)
print(f"Test result: {result}")
return result
return wrapper

@log_test
def test_example():
# Test logic here
return "Pass"

test_example()

Exception Handling: Decorators can be used to handle exceptions in test functions and provide custom error messages or actions:

def handle_exceptions(func):
def wrapper(*args, *kwargs): try: return func(args, **kwargs)
except Exception as e:
print(f"Test failed: {e}")
# Additional actions can be taken here, like raising a custom exception
raise
return wrapper

@handle_exceptions
def test_example():
# Test logic here
raise ValueError("Test failed")

test_example()

Parameterized Tests: Decorators can be used to create parameterized tests, where the same test logic is executed with different inputs:

def parameterized_test(parameters):
def decorator(func):
def wrapper():
for parameter in parameters:
func(parameter)
return wrapper
return decorator

@parameterized_test([1, 2, 3])
def test_example(parameter):
print(f"Running test with parameter: {parameter}")
# Test logic here

test_example()

Retry: Decorators can add retry logic to test functions, useful for dealing with flaky tests that occasionally fail due to external factors:

import time

def retry(retries=3, delay=1):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, *kwargs): for _ in range(retries): try: return func(args, **kwargs)
except Exception as e:
print(f"Test failed: {e}. Retrying…")
time.sleep(delay)
raise
return wrapper
return decorator

@retry() # Retry 3 times with a delay of 1 second between retries
def test_example():
# Test logic here
import random
if random.random() < 0.5:
raise ValueError("Random failure")

test_example()

Skip Test: Decorators can mark certain test functions to be skipped under certain conditions:

def skip_test(condition=True, reason="Test skipped"):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, *kwargs): if condition: print(f"Skipping test: {reason}") return else: return func(args, **kwargs)
return wrapper
return decorator

@skip_test(condition=True, reason="Not implemented yet")
def test_example():
# Test logic here
pass

test_example()

Data Driven Tests: Decorators can be used to implement data-driven testing, where a test function is executed with different sets of input data:

def data_driven_test(data):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, *kwargs): for test_data in data: func(args, **kwargs, test_data)
return wrapper
return decorator

#Example usage

testdata = [
(1, 1, 2),
(2, 3, 5),
(10, -5, 5)
]

@data_driven_test(testdata)
def test_addition(a, b, expected):
assert a + b == expected

test_addition()

Mark Tests: Decorators can mark test functions with metadata, which can be later used for selective test execution or to group tests:

def mark_test(metadata):
def decorator(func):
setattr(func, 'metadata', metadata)
return func
return decorator

#Example usage

@mark_test(metadata={"category": "math", "priority": 1})
def test_addition():
assert 1 + 1 == 2

#Later, you can filter or group tests based on metadata

#For instance, running only tests in the "math" category

selected_tests = [test_func for test_func in all_tests if getattr(test_func, 'metadata', {}).get('category') == 'math']

Parallel Tests: Decorators can be used to mark test functions that can be run in parallel:

def run_in_parallel(num_threads):
def decorator(func):
def wrapper(*args, **kwargs):
# Run the test function in parallel
pass # Implement parallel execution logic
return wrapper
return decorator

#Example usage

@run_in_parallel(num_threads=4)
def test_example():
# Test logic here
pass

for more information, please visit https://xpertlab.com/introduction-to-seleniumbase/
https://www.kite.com/blog/python/python-decorators/