Using Python Decorators for API Automation Testing

In API automation testing, common functionalities like logging, authentication, and performance monitoring can be abstracted using Python decorators, which allow adding behavior to functions without modifying their source code.

Decorator basics: a decorator is a higher‑order function that takes a function as an argument and returns a new function. Example definition:

def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        # pre‑processing
        result = original_function(*args, **kwargs)
        # post‑processing
        return result
    return wrapper_function

Applying decorators to API test methods enables automatic request/response logging. Example:

def log_decorator(api_func):
    def wrapper(*args, **kwargs):
        print(f"Request: {api_func.__name__}()")
        result = api_func(*args, **kwargs)
        print(f"Response: {api_func.__name__}() -> {result}")
        return result
    return wrapper

class ApiTest:
    @log_decorator
    def test_login(self, username, password):
        pass

    @log_decorator
    def test_create_user(self, email, password):
        pass

Beyond testing, decorators are useful for authentication, logging, caching, performance monitoring, and transaction handling.

A complete example combines a logging decorator and a data‑saving decorator that writes request data to a MySQL database. The code demonstrates importing requests, json, pymysql, using @wraps, defining log_decorator, save_data_decorator, save_data_to_mysql, and a get_user_info function decorated with both.

import requests, json, pymysql
from functools import wraps

def log_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"请求URL: {func.__name__}")
        print(f"请求参数: {kwargs}")
        response = func(*args, **kwargs)
        print(f"响应结果: {response}")
        return response
    return wrapper

def save_data_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        response = func(*args, **kwargs)
        save_data_to_mysql(response)
        return response
    return wrapper

def save_data_to_mysql(data):
    conn = pymysql.connect(host='localhost', user='root', password='password', database='mock_data')
    cur = conn.cursor()
    cur.execute("""CREATE TABLE IF NOT EXISTS api_data (id INT AUTO_INCREMENT PRIMARY KEY, url VARCHAR(255), response TEXT)""")
    cur.execute("INSERT INTO api_data (url, response) VALUES (%s, %s)", (data['url'], json.dumps(data['response'])))
    conn.commit()
    cur.close()
    conn.close()

@log_decorator
@save_data_decorator
def get_user_info(user_id):
    url = f"https://api.example.com/users/{user_id}"
    resp = requests.get(url)
    return {'url': url, 'response': resp.json()}

get_user_info(1)
get_user_info(2)

The article concludes that Python decorators simplify code, promote reuse, and enhance maintainability in API automation testing and many other scenarios.