Build a Python Test Data Factory with Faker and Decorators for Reliable Automated Tests

In automated testing, hard‑coding usernames, phone numbers, emails and order IDs leads to duplicate data, non‑standard formats, and maintenance headaches. The article proposes a Python‑based test data factory that generates high‑quality, unique, structured data with a single decorator.

Core Goals

Automatically produce usernames, phone numbers, emails, ID cards, etc., that follow business rules.

Guarantee global uniqueness to avoid registration conflicts.

Allow custom prefixes/suffixes (e.g., auto_test_order_123).

Inject generated data as keyword arguments into test functions.

Integrate with pytest with zero intrusion.

Technical Stack

The solution uses the Faker library for realistic data and a Python decorator to perform automatic injection.

pip install faker

Implementation Details

A global Faker instance (Chinese locale) and a thread‑safe uniqueness lock are created. The helper _ensure_unique checks a global set of used values and, if necessary, appends incremental suffixes until a unique value is found.

import functools
import threading
from typing import Dict, Any, Optional
from faker import Faker

_faker = Faker("zh_CN")  # Chinese names, emails, etc.
_unique_lock = threading.Lock()
_used_values = set()

def _ensure_unique(value: str, max_retries=10) -> str:
    """Ensure a value is unique, retrying with suffixes if needed."""
    with _unique_lock:
        if value not in _used_values:
            _used_values.add(value)
            return value
    for i in range(1, max_retries + 1):
        new_value = f"{value}_{i}"
        with _unique_lock:
            if new_value not in _used_values:
                _used_values.add(new_value)
                return new_value
    raise RuntimeError(f"Unable to generate unique value for {value}")

def generate_test_data(
    username: bool = False,
    email: bool = False,
    phone: bool = False,
    id_card: bool = False,
    prefix: str = "auto_test",
    custom: Optional[Dict[str, Any]] = None,
):
    """Decorator that creates test data and passes it to the wrapped function."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            test_data = {}
            timestamp = int(func.__name__.__hash__() % 1e8)
            if username:
                raw = _faker.user_name()
                test_data["username"] = _ensure_unique(f"{prefix}_{raw}_{timestamp}")
            if email:
                raw = _faker.free_email()
                test_data["email"] = _ensure_unique(f"{prefix}.{raw}")
            if phone:
                test_data["phone"] = _faker.phone_number()
            if id_card:
                test_data["id_card"] = _faker.ssn()  # Chinese ID when locale is zh_CN
            if custom:
                for key, template in custom.items():
                    if "{timestamp}" in template:
                        value = template.format(timestamp=int(time.time()))
                    else:
                        value = template
                    test_data[key] = _ensure_unique(value)
            return func(*args, test_data=test_data, **kwargs)
        return wrapper
    return decorator

Usage Examples

Scenario 1 – Register a new user

@generate_test_data(username=True, email=True, phone=True)
def test_user_registration(test_data):
    resp = requests.post("/api/register", json={
        "username": test_data["username"],
        "email": test_data["email"],
        "phone": test_data["phone"]
    })
    assert resp.status_code == 201

# Example generated values
# username: auto_test_zhangsan_12345678
# email: [email protected]
# phone: 13812345678

Scenario 2 – Create an order with a unique order number

@generate_test_data(custom={"order_no": "AUTO_ORD_{timestamp}"})
def test_create_order(test_data):
    resp = requests.post("/api/orders", json={
        "order_no": test_data["order_no"],
        "amount": 99.9
    })
    assert resp.status_code == 200
# Example: order_no = AUTO_ORD_1706123456

Scenario 3 – Real‑name authentication (ID card)

@generate_test_data(username=True, id_card=True)
def test_real_name_auth(test_data):
    resp = requests.post("/api/kyc", json={
        "name": test_data["username"],
        "id_card": test_data["id_card"]
    })
    assert resp.status_code == 200
# Faker‑generated ID cards follow checksum rules.

Uniqueness Guarantees

Concurrent execution is protected by threading.Lock around a global set.

Duplicate test names are avoided by appending a hash‑based timestamp.

Custom templates that clash are automatically suffixed ( _1, _2, …).

Periodic cleanup of the _used_values set can prevent memory leaks (e.g., clear every 1,000 generations).

Advanced Tips

pytest fixture integration : place the data‑generation logic in a fixture and let the decorator merely declare the need.

@pytest.fixture
def test_user_data():
    return generate_user_data()

def test_login(test_user_data):
    ...

Data masking after tests : log or clean up sensitive fields such as ID cards once the test finishes.

Internationalization : create separate Faker instances for different locales.

_faker_en = Faker("en_US")
_faker_cn = Faker("zh_CN")
# Switch based on environment

Why Use a Test Data Factory?

Eliminates manual string concatenation.

Provides globally unique data, preventing conflicts.

Ensures data conforms to real‑world business rules (e.g., valid phone prefixes).

Reduces boilerplate: a single decorator declares the required fields.

Adopting this approach makes test cases faster to write, more reliable, and closer to real user behavior.

Action Recommendations

Install faker in your project.

Save the decorator in utils/data_factory.py.

Replace all hard‑coded test data generation with the new decorator.

Enjoy quicker test authoring, fewer failures due to data clashes, and more realistic test scenarios.