Pytest Fixtures Explained — Setup, Scopes, and Real-World Patterns

import pytest

# --- Without fixtures (the painful way) ---
# Notice how setup is duplicated in every test. This is the problem we're solving.

def test_user_has_default_role_no_fixture():
    # We have to manually create everything every single time
    user = {"id": 1, "username": "alice", "role": "viewer"}
    assert user["role"] == "viewer"

def test_user_can_be_promoted_no_fixture():
    # Exact same setup duplicated — a maintenance nightmare
    user = {"id": 1, "username": "alice", "role": "viewer"}
    user["role"] = "admin"
    assert user["role"] == "admin"


# --- With fixtures (the right way) ---

@pytest.fixture
def sample_user():
    """
    This fixture creates a fresh user dict before each test that requests it.
    Pytest injects this automatically — the test never calls sample_user() directly.
    """
    user = {"id": 1, "username": "alice", "role": "viewer"}
    return user  # pytest hands this value to any test that lists 'sample_user' as a param


def test_user_has_default_role(sample_user):  # <-- pytest sees 'sample_user', runs the fixture
    assert sample_user["role"] == "viewer"

def test_user_can_be_promoted(sample_user):   # <-- fresh copy of the user dict for this test
    sample_user["role"] = "admin"
    assert sample_user["role"] == "admin"

# Run with: pytest test_user_service.py -v

import pytest
import sqlite3
import os

@pytest.fixture
def temporary_database():
    """
    Creates a real SQLite database file before the test, yields the connection,
    then closes the connection and deletes the file — no matter what happens in the test.
    """
    db_path = "test_temp.db"
    
    # --- SETUP: everything before yield ---
    connection = sqlite3.connect(db_path)
    cursor = connection.cursor()
    cursor.execute(
        "CREATE TABLE orders (id INTEGER PRIMARY KEY, product TEXT, quantity INTEGER)"
    )
    connection.commit()
    print(f"\n[FIXTURE] Database created at {db_path}")
    
    yield connection  # <-- the test receives this connection object
    
    # --- TEARDOWN: everything after yield ---
    # This block runs even if the test raises an exception or fails an assertion
    connection.close()
    os.remove(db_path)
    print(f"[FIXTURE] Database deleted — {db_path} cleaned up")


def test_insert_order(temporary_database):
    # 'temporary_database' IS the yielded connection object
    cursor = temporary_database.cursor()
    cursor.execute("INSERT INTO orders (product, quantity) VALUES ('keyboard', 2)")
    temporary_database.commit()
    
    cursor.execute("SELECT product, quantity FROM orders WHERE product = 'keyboard'")
    result = cursor.fetchone()
    
    assert result == ("keyboard", 2)


def test_empty_database_has_no_orders(temporary_database):
    # Each test gets a FRESH database — the previous test's insert doesn't bleed in
    cursor = temporary_database.cursor()
    cursor.execute("SELECT COUNT(*) FROM orders")
    count = cursor.fetchone()[0]
    
    assert count == 0  # proves teardown + fresh setup worked

# Run with: pytest test_database_connection.py -v -s

import pytest

# ---- SESSION scope: created ONCE for the entire test run ----
@pytest.fixture(scope="session")
def application_config():
    """
    Simulates loading a config file — expensive, so we do it once per session.
    Immutable data is safe to share across all tests.
    """
    print("\n[SESSION] Loading application config (happens once)")
    config = {
        "api_base_url": "https://api.example.com",
        "max_retries": 3,
        "timeout_seconds": 30,
    }
    yield config
    print("[SESSION] Config teardown (happens once at end)")


# ---- MODULE scope: created once per test file ----
@pytest.fixture(scope="module")
def database_schema(application_config):
    """
    Uses the session-scoped config to set up a schema once per module.
    A fixture CAN depend on a wider-scoped fixture, but NOT a narrower one.
    """
    print(f"\n[MODULE] Setting up schema using {application_config['api_base_url']}")
    schema = {"tables": ["users", "products", "orders"], "version": "1.0"}
    yield schema
    print("[MODULE] Schema teardown")


# ---- FUNCTION scope (default): fresh for every test ----
@pytest.fixture  # scope="function" is the default — no need to specify
def active_user_session(database_schema):
    """
    Creates a fresh user session for each test. Depends on the module-scoped schema.
    A narrower fixture CAN safely depend on a wider one.
    """
    print("\n[FUNCTION] Creating user session")
    session = {
        "session_id": "abc-123",
        "username": "alice",
        "schema_version": database_schema["version"]
    }
    yield session
    print("[FUNCTION] Destroying user session")


# --- TESTS ---

def test_session_has_correct_schema_version(active_user_session):
    assert active_user_session["schema_version"] == "1.0"

def test_session_belongs_to_alice(active_user_session):
    # This test gets a FRESH user session — but reuses the same database_schema
    assert active_user_session["username"] == "alice"

def test_config_has_retry_limit(application_config):
    # The session-scoped config is the exact same object as in the other tests
    assert application_config["max_retries"] == 3

# Run with: pytest test_scoped_fixtures.py -v -s
# Watch the print statements to see EXACTLY when each scope initialises and tears down

# conftest.py — place this in your project root or test directory
# pytest auto-discovers this file. No imports needed in your test files.

import pytest


@pytest.fixture(scope="session")
def api_client():
    """
    Simulates a configured HTTP client shared across all test files.
    In a real project this might be a requests.Session or httpx.Client.
    """
    class FakeApiClient:
        def __init__(self, base_url):
            self.base_url = base_url
            self.headers = {"Authorization": "Bearer test-token-xyz"}
        
        def get(self, endpoint):
            # Simulating a response for illustration purposes
            return {"status": 200, "url": f"{self.base_url}{endpoint}"}
    
    client = FakeApiClient(base_url="https://api.example.com")
    print("\n[conftest] API client initialised")
    yield client
    print("[conftest] API client closed")


@pytest.fixture
def admin_user():
    """A reusable admin user available to any test file in this directory tree."""
    return {"id": 99, "username": "admin", "role": "admin", "email": "admin@example.com"}


@pytest.fixture
def viewer_user():
    """A reusable read-only user for permission boundary tests."""
    return {"id": 7, "username": "carol", "role": "viewer", "email": "carol@example.com"}


# ---------------------------------------------------------------
# test_permissions.py — in the same directory as conftest.py
# Note: NO import of conftest needed. Pytest resolves fixtures by name.
# ---------------------------------------------------------------

# import pytest  # (only needed if you use pytest.mark etc.)

def test_admin_can_access_dashboard(api_client, admin_user):
    # Both fixtures come from conftest.py — zero imports
    response = api_client.get("/dashboard")
    assert response["status"] == 200
    assert admin_user["role"] == "admin"

def test_viewer_cannot_modify_settings(viewer_user):
    assert viewer_user["role"] == "viewer"
    # In a real test you'd call your auth system and assert 403

# Run with: pytest test_permissions.py -v -s