Boost API Automation Testing with Parameterized Python Decorators

In API automation testing, repetitive setup steps such as logging in, obtaining tokens, configuring headers, and handling retries can lead to redundant and error‑prone code. Parameterized Python decorators provide a powerful way to encapsulate these concerns, making test scripts shorter, clearer, and easier to maintain.

Example 1: Login State Decorator

import requests

def login_required(username='admin', password='password'):
    token = None
    def inner_decorator(func):
        def wrapper(*args, **kwargs):
            nonlocal token
            if not token:
                response = requests.post('http://api.example.com/login', json={'username': username, 'password': password})
                token = response.json()['token']
            headers = kwargs.setdefault('headers', {})
            headers['Authorization'] = f'Bearer {token}'
            return func(*args, **kwargs)
        return wrapper
    return inner_decorator

@login_required()
def test_api_endpoint():
    response = requests.get('http://api.example.com/data')
    assert response.status_code == 200

test_api_endpoint()

Example 2: Retry Mechanism

import time

def retry(max_attempts=3, delay=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt < max_attempts - 1:
                        time.sleep(delay)
                    else:
                        raise e
        return wrapper
    return decorator

@retry(max_attempts=5, delay=2)
def test_unstable_api():
    response = requests.get('http://api.example.com/unstable')
    assert response.status_code == 200

test_unstable_api()

Example 3: Environment Selection

def set_environment(env='prod'):
    base_url = {
        'prod': 'http://api.example.com',
        'dev': 'http://api.dev.example.com'
    }
    def decorator(func):
        def wrapper(*args, **kwargs):
            kwargs['base_url'] = base_url[env]
            return func(*args, **kwargs)
        return wrapper
    return decorator

@set_environment(env='dev')
def test_api_endpoint(base_url):
    response = requests.get(f'{base_url}/data')
    assert response.status_code == 200

test_api_endpoint()

Example 4: Data‑Driven Testing

def data_driven(data):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for item in data:
                result = func(*item)
                results.append(result)
            return results
        return wrapper
    return decorator

@data_driven([(1,), (2,), (3,)])
def test_with_data(x):
    return x * 2

print(test_with_data())

Example 5: Logging Decorator

import logging

def log_test(level=logging.INFO):
    logger = logging.getLogger('test_logger')
    def decorator(func):
        def wrapper(*args, **kwargs):
            logger.log(level, f"Running test: {func.__name__}")
            result = func(*args, **kwargs)
            logger.log(level, f"Test completed: {func.__name__}")
            return result
        return wrapper
    return decorator

@log_test()
def test_api_endpoint():
    response = requests.get('http://api.example.com/data')
    assert response.status_code == 200

test_api_endpoint()

Example 6: Performance Monitoring

import time

def performance_monitor(threshold=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            elapsed = time.time() - start_time
            if elapsed > threshold:
                print(f"Warning: {func.__name__} took {elapsed:.2f}s which is greater than the threshold of {threshold}s")
            return result
        return wrapper
    return decorator

@performance_monitor(threshold=0.5)
def test_api_endpoint():
    time.sleep(0.6)
    return True

test_api_endpoint()

Example 7: Permission Check

def permission_required(permission='admin'):
    def decorator(func):
        def wrapper(*args, **kwargs):
            user_permissions = kwargs.get('user_permissions', [])
            if permission not in user_permissions:
                raise PermissionError(f"User does not have required permission: {permission}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@permission_required(permission='admin')
def test_admin_only_api(user_permissions):
    return True

test_admin_only_api(user_permissions=['admin', 'user'])

Example 8: Mock Response

import unittest.mock

def mock_response(status_code=200):
    def decorator(func):
        def wrapper(*args, **kwargs):
            with unittest.mock.patch('requests.get') as mock_get:
                mock_get.return_value.status_code = status_code
                return func(*args, **kwargs)
        return wrapper
    return decorator

@mock_response(status_code=200)
def test_api_endpoint():
    response = requests.get('http://api.example.com/data')
    assert response.status_code == 200

test_api_endpoint()

Example 9: Cleanup Decorator

def clean_up(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        # cleanup logic here
        return result
    return wrapper

@clean_up
def test_api_endpoint():
    # test logic
    pass

test_api_endpoint()

Example 10: Test Tagging

def tag(tags):
    def decorator(func):
        func.tags = tags
        return func
    return decorator

@tag(['smoke', 'regression'])
def test_api_endpoint():
    # test logic
    pass

print(getattr(test_api_endpoint, 'tags', []))

These examples illustrate how parameterized decorators can dramatically reduce boilerplate in API test suites, improve readability, and make maintenance easier. Apply the patterns that fit your project's needs, and adapt them to your specific constraints for more efficient automated testing.