6 Essential Selenium Python Libraries for Test Automation in 2026

pytest fixtures are a core feature that eliminate duplicate test code and centralize setup and teardown logic. Mastering yield, scope, and conftest.py will help you write maintainable, production-grade tests.

📌 Who This Article Is For

📖 What You’ll Learn in This Article

I have worked as a QA engineer for over 15 years, focusing on test automation with Selenium, Playwright, and pytest.
This article goes beyond textbook explanations — it covers real problems I’ve seen in actual codebases, along with practical solutions.

What Are pytest Fixtures?

A pytest fixture is a mechanism for managing setup, teardown, and shared data needed before and after tests.
You define a function with the @pytest.fixture decorator, and pytest automatically injects it into any test function that declares a matching argument name.

The concept is similar to @BeforeEach / @AfterEach in JUnit, but pytest fixtures are more powerful — they support flexible scope control, nesting, and parameterization.

Basic Syntax and Simple Usage

Let’s start with the smallest possible example.

import pytest

# ① Define a fixture
@pytest.fixture
def sample_data() -> dict:
    return {"user": "alice", "age": 30}

# ② Argument name = fixture name → pytest auto-injects it
def test_user_name(sample_data: dict) -> None:
    assert sample_data["user"] == "alice"

def test_user_age(sample_data: dict) -> None:
    assert sample_data["age"] == 30

As long as the argument name matches the fixture name, pytest handles injection automatically.
No import is needed, and multiple test functions can share the same fixture.

5 Recommended Fixture Patterns

1. Use yield to Combine Setup and Teardown

This is the most commonly used pattern in real projects. Everything before yield is setup; everything after is teardown.
The teardown code runs regardless of whether the test passes or fails.

import pytest
import requests
import logging

logger = logging.getLogger(__name__)

@pytest.fixture
def api_session() -> requests.Session:
    # --- Setup ---
    session = requests.Session()
    session.headers.update({"Content-Type": "application/json"})
    logger.info("Session opened")

    yield session  # ← handed to the test function

    # --- Teardown (always runs, even on test failure) ---
    session.close()
    logger.info("Session closed")


def test_get_users(api_session: requests.Session) -> None:
    response = api_session.get("https://example.com/api/users")  # sample URL
    assert response.status_code == 200

You can technically implement teardown with return using try/finally, but pytest’s yield pattern lets you write teardown more naturally.
For resources that need to be closed — DB connections, HTTP sessions, browser drivers — the yield pattern is the widely adopted approach in real projects.

2. Use scope to Reuse Expensive Operations

By default, fixtures are created and destroyed for each individual test. Setting a scope extends their lifetime so they can be shared across multiple tests.

import pytest
import requests

# Login API is called only once for the entire test session
@pytest.fixture(scope="session")
def auth_token() -> str:
    response = requests.post(
        "https://example.com/api/auth/login",  # sample URL
        json={"username": "testuser", "password": "secret"},
        timeout=(3, 10),
    )
    response.raise_for_status()
    data = response.json()
    assert "token" in data
    return data["token"]


def test_get_profile(auth_token: str) -> None:
    headers = {"Authorization": f"Bearer {auth_token}"}
    res = requests.get(
        "https://example.com/api/profile",  # sample URL
        headers=headers,
        timeout=(3, 10),
    )
    assert res.status_code == 200

3. Share Fixtures via conftest.py

Fixtures defined in conftest.py are available to all tests in the same directory and its subdirectories — no import needed.
It’s the standard place to put shared fixtures for your whole team.

# Directory layout
tests/
├── conftest.py          ← shared fixtures for all tests
├── test_auth.py
└── api/
    ├── conftest.py      ← fixtures scoped to the api/ directory only
    └── test_users.py

# tests/conftest.py
import pytest

@pytest.fixture(scope="session")
def base_url() -> str:
    return "https://example.com"  # sample URL (use env vars in real projects)

@pytest.fixture
def headers(auth_token: str) -> dict:
    return {"Authorization": f"Bearer {auth_token}"}

# tests/test_auth.py
# No import needed — conftest.py fixtures are auto-discovered
def test_base_url(base_url: str) -> None:
    assert "example" in base_url

You can place conftest.py at multiple directory levels, making it easy to separate “project-wide fixtures” from “module-specific fixtures”.

4. Use params for Data-Driven Testing

The params option lets you run a test multiple times with different inputs by cycling through a list of values.

import pytest
import requests

INVALID_PAYLOADS = [
    pytest.param({"username": "", "password": "pass"}, id="empty_username"),
    pytest.param({"username": "user", "password": ""}, id="empty_password"),
    pytest.param({}, id="empty_body"),
]

# `request` is a special built-in argument pytest provides automatically
# (optional type hint: pytest.FixtureRequest)
@pytest.fixture(params=INVALID_PAYLOADS)
def invalid_login_payload(request) -> dict:
    return request.param


def test_login_validation(invalid_login_payload: dict) -> None:
    response = requests.post(
        "https://example.com/api/auth/login",  # sample URL
        json=invalid_login_payload,
        timeout=(3, 10),
    )
    # All invalid requests should return a 4xx response
    assert response.status_code in (400, 422)

Adding pytest.param(..., id="...") gives each case a name, making failure output much easier to read.

fixture params vs. @pytest.mark.parametrize — a quick comparison

5. Inject Fixtures into Fixtures to Separate Concerns

A fixture can receive other fixtures as arguments. Splitting “connection info”, “authentication”, and “client creation” into separate fixtures keeps each responsibility clear and small.

import pytest
import requests

# 1. Base URL (session scope)
@pytest.fixture(scope="session")
def base_url() -> str:
    return "https://example.com/api"  # sample URL (use env vars in real projects)


# 2. Auth token (session scope — injects base_url)
@pytest.fixture(scope="session")
def auth_token(base_url: str) -> str:
    response = requests.post(
        f"{base_url}/auth/login",
        json={"username": "testuser", "password": "secret"},
        timeout=(3, 10),
    )
    response.raise_for_status()
    data = response.json()
    assert "token" in data
    return data["token"]


# 3. Authenticated session (function scope — injects auth_token)
@pytest.fixture
def authed_session(base_url: str, auth_token: str) -> requests.Session:
    session = requests.Session()
    session.headers.update({
        "Authorization": f"Bearer {auth_token}",
        "Content-Type": "application/json",
    })
    yield session
    session.close()


# Tests only need to receive authed_session
def test_get_users(authed_session: requests.Session) -> None:
    res = authed_session.get(
        "https://example.com/api/users",  # sample URL
        timeout=(3, 10),
    )
    assert res.status_code == 200

With this structure, switching environments only requires changing base_url.
Test functions stay clean — they only need to know about authed_session.

6. Use autouse to Apply a Fixture Automatically (Advanced)

Setting autouse=True applies the fixture to every test automatically, without needing to declare it as an argument.
Common uses include logging, timezone locking, and DB reset between tests.

import pytest
import logging

logger = logging.getLogger(__name__)

# Logs the start and end of every test automatically
@pytest.fixture(autouse=True)
def log_test_name(request: pytest.FixtureRequest) -> None:
    logger.info(f"▶ START: {request.node.name}")
    yield
    logger.info(f"■ END  : {request.node.name}")

Useful Built-in Fixtures

pytest ships with several built-in fixtures that are ready to use without any setup of your own.

from pathlib import Path
import pytest

# tmp_path: a fresh temporary directory is auto-created per test
def test_write_csv(tmp_path: Path) -> None:
    output_file = tmp_path / "result.csv"
    output_file.write_text("id,name\n1,alice\n")
    assert output_file.read_text().startswith("id,name")

# monkeypatch: temporarily overrides an env var and restores it after the test
def test_api_base_url(monkeypatch: pytest.MonkeyPatch) -> None:
    monkeypatch.setenv("API_BASE_URL", "https://staging.example.com")
    import os
    assert os.environ["API_BASE_URL"] == "https://staging.example.com"

7 Common Pitfalls in Real Projects

Frequently Asked Questions (FAQ)

Summary

Using pytest fixtures well leads to less duplicated code, no forgotten teardowns, and a faster test suite overall.
To start, just master the yield pattern and how to use conftest.py — that’s enough to handle most everyday test automation work.

A practical first step: pick one setup block in your existing tests and extract it into a fixture. That’s all it takes to get started.