Why Fixtures Exist and How They Work
#**The problem fixtures solve:**
Imagine five test functions that all need a populated user object. Without fixtures, you'd either repeat the setup code in each test or share a module-level variable — both are fragile. pytest fixtures solve this cleanly.
A fixture is a function decorated with `@pytest.fixture`. Any test that declares it as a parameter receives the fixture's return value automatically — no import, no call, just the name:
```python
import pytest
@pytest.fixture
def user():
return {'name': 'Alice', 'email': '[email protected]', 'active': True}
def test_user_is_active(user): # pytest sees 'user' parameter → runs fixture
assert user['active'] is True
def test_user_has_email(user): # same fixture, separate call
assert '@' in user['email']
```
pytest resolves fixture names by matching parameter names. If a test has a parameter called `user`, pytest finds a fixture named `user` and injects it. This is *dependency injection by name*.
**The yield pattern — setup and teardown:**
Use `yield` instead of `return` when you need cleanup after the test finishes:
```python
@pytest.fixture
def temp_file(tmp_path):
path = tmp_path / 'data.txt'
path.write_text('hello world') # ← setup runs before the test
yield path # ← test receives the path here
path.unlink(missing_ok=True) # ← teardown runs after the test, even on failure
```
Everything before `yield` is setup. Everything after is teardown. It's the equivalent of `try / finally` but expressed as a linear flow.
**Fixture scope — how long a fixture lives:**
By default, a fixture runs once per test function (`scope='function'`). You can change this:
```python
@pytest.fixture(scope='module')
def db_connection():
conn = create_expensive_connection()
yield conn
conn.close()
```
With `scope='module'`, the fixture runs *once* for the entire test file and the connection is shared across all tests in it. This is useful for expensive setup like DB connections or loading large files.
| Scope | Fixture runs once per |
|---|---|
| `function` (default) | each test |
| `class` | each test class |
| `module` | each test file |
| `session` | entire `pytest` run |
**One important rule:**
Never call a fixture function directly in a test. Let pytest inject it:
```python
# WRONG
def test_something():
u = user() # this just calls the plain function, bypassing pytest
# RIGHT
def test_something(user): # pytest injects the fixture
...
```