# WRONG -- procedural, no encapsulation
def test_create_user():
    response = httpx.post("/users", json={"email": "a@b.com"})
    assert response.status_code == 201
# CORRECT -- OOP, inherits BaseTest, uses service class
@allure.feature("User Management")
class TestCreateUser(BaseTest):
    def test_create_user_returns_201(self):
        data = self.gen.create_user_request()
        response = self.users_api.create_user(data)
        assert response.status_code == 201

import pytest
import allure
from framework.clients.http_client import HTTPClient
from framework.config.settings import Settings
class BaseTest:
    """Base class for ALL test classes."""
    client: HTTPClient
    settings: Settings
    @pytest.fixture(autouse=True)
    def _setup_base(self, http_client: HTTPClient, settings: Settings):
        """Inject shared dependencies."""
        self.client = http_client
        self.settings = settings
class BaseAuthenticatedTest(BaseTest):
    """Base for tests requiring authentication."""
    @pytest.fixture(autouse=True)
    def _setup_auth(self, authenticated_client: HTTPClient):
        self.client = authenticated_client

from framework.base.base_api_client import BaseAPIClient
class BaseAPIClient:
    """Base for all API service classes."""
    def __init__(self, client: HTTPClient):
        self.client = client
class UsersAPI(BaseAPIClient):
    ENDPOINT = "/api/v1/users"
    @allure.step("POST /users — Create user: {data.email}")
    def create_user(self, data: CreateUserRequest) -> httpx.Response:
        return self.client.post(self.ENDPOINT, json=data.model_dump())
    @allure.step("GET /users/{user_id}")
    def get_user(self, user_id: int) -> httpx.Response:
        return self.client.get(f"{self.ENDPOINT}/{user_id}")
    @allure.step("GET /users — List (page={page})")
    def list_users(self, page: int = 1, per_page: int = 20) -> httpx.Response:
        return self.client.get(self.ENDPOINT, params={"page": page, "per_page": per_page})
    @allure.step("PATCH /users/{user_id}")
    def update_user(self, user_id: int, data: dict) -> httpx.Response:
        return self.client.patch(f"{self.ENDPOINT}/{user_id}", json=data)
    @allure.step("DELETE /users/{user_id}")
    def delete_user(self, user_id: int) -> httpx.Response:
        return self.client.delete(f"{self.ENDPOINT}/{user_id}")

# conftest.py
import pytest
from framework.clients.http_client import HTTPClient
from framework.config.settings import Settings
@pytest.fixture(scope="session")
def settings() -> Settings:
    return Settings()
@pytest.fixture(scope="session")
def http_client(settings: Settings) -> HTTPClient:
    client = HTTPClient(settings)
    yield client
    client.close()
@pytest.fixture(scope="session")
def auth_token(http_client, settings) -> str:
    from api.auth_api import AuthAPI
    auth = AuthAPI(http_client)
    resp = auth.login(settings.TEST_USER_EMAIL, settings.TEST_USER_PASSWORD)
    return resp.json()["access_token"]
@pytest.fixture
def authenticated_client(settings, auth_token) -> HTTPClient:
    client = HTTPClient(settings, token=auth_token)
    yield client
    client.close()

# tests/test_users/conftest.py
import pytest
from api.users_api import UsersAPI
from framework.helpers.data_generator import DataGenerator
@pytest.fixture
def users_api(http_client) -> UsersAPI:
    return UsersAPI(http_client)
@pytest.fixture
def created_user(users_api: UsersAPI) -> dict:
    """Create a user and return response body. Cleanup after test."""
    data = DataGenerator.create_user_request()
    response = users_api.create_user(data)
    user = response.json()
    yield user
    users_api.delete_user(user["id"])  # Cleanup

@allure.feature("Input Validation")
class TestUserValidation(BaseTest):
    @pytest.mark.parametrize("field,value,error_field", [
        ("email", "not-email", "email"),
        ("email", "", "email"),
        ("password", "123", "password"),
        ("name", "", "name"),
        ("name", "x" * 256, "name"),
    ], ids=[
        "invalid-email-format",
        "empty-email",
        "short-password",
        "empty-name",
        "name-too-long",
    ])
    @allure.story("Field validation")
    def test_create_user_field_validation(self, field: str, value: str, error_field: str):
        data = self.gen.create_user_request(**{field: value})
        response = self.users_api.create_user(data)
        assert response.status_code == 422
        errors = response.json()
        assert any(error_field in str(e) for e in errors.get("detail", []))

@allure.feature("Authorization")
class TestUserAuthorization(BaseTest):
    @pytest.mark.parametrize("method,endpoint,expected", [
        ("GET", "/api/v1/users", 401),
        ("POST", "/api/v1/users", 401),
        ("GET", "/api/v1/users/1", 401),
        ("DELETE", "/api/v1/users/1", 401),
    ], ids=["list", "create", "get", "delete"])
    @allure.story("Unauthorized access returns 401")
    def test_unauthenticated_returns_401(self, method: str, endpoint: str, expected: int):
        response = getattr(self.client, method.lower())(endpoint)
        assert response.status_code == expected

# pyproject.toml
[tool.pytest.ini_options]
markers = [
    "smoke: Quick sanity checks (< 30 seconds total)",
    "regression: Full regression suite",
    "critical: Business-critical flows",
    "negative: Negative/error scenarios",
    "slow: Tests > 10 seconds",
    "flaky: Known flaky tests (quarantined)",
]

@pytest.mark.smoke
@pytest.mark.critical
class TestAuthSmoke(BaseAuthenticatedTest):
    def test_login_returns_token(self): ...
    def test_token_refresh_works(self): ...

# Run smoke suite
pytest -m smoke --alluredir=allure-results
 
# Run everything except flaky
pytest -m "not flaky"
 
# Run critical regression
pytest -m "critical and regression"

# Install
pip install pytest-xdist
 
# Run parallel (auto-detect CPU count)
pytest -n auto --alluredir=allure-results
 
# Fixed worker count
pytest -n 4

import allure
from framework.models.response_models import ErrorResponse
class Assertions:
    """Custom assertion helpers with Allure integration."""
    @staticmethod
    @allure.step("Assert status code is {expected}")
    def assert_status(response, expected: int):
        assert response.status_code == expected, (
            f"Expected {expected}, got {response.status_code}. "
            f"Body: {response.text[:200]}"
        )
    @staticmethod
    @allure.step("Assert response matches schema {model.__name__}")
    def assert_schema(response, model: type):
        """Validate response body against Pydantic model."""
        data = response.json()
        parsed = model.model_validate(data)
        return parsed
    @staticmethod
    @allure.step("Assert error response contains: {expected_detail}")
    def assert_error(response, expected_status: int, expected_detail: str | None = None):
        assert response.status_code == expected_status
        if expected_detail:
            error = ErrorResponse.model_validate(response.json())
            assert expected_detail in error.detail