Conftest fixtures (shared across files) in PyTest - Deep Dive

Overview - Conftest fixtures (shared across files)

What is it?

Conftest fixtures in pytest are special functions that provide reusable setup or data for tests. They live in a file named conftest.py and can be shared across multiple test files in the same directory or subdirectories. This allows tests to use common resources without repeating code. They help organize and simplify test setup in larger projects.

Why it matters

Without conftest fixtures, each test file would need to duplicate setup code, making tests harder to maintain and more error-prone. Sharing fixtures across files saves time, reduces bugs, and keeps tests consistent. It makes adding or changing test setup easier, improving overall test quality and developer productivity.

Where it fits

Before learning conftest fixtures, you should understand basic pytest fixtures and how to write simple tests. After mastering conftest fixtures, you can explore advanced fixture scopes, parameterization, and plugin development to customize pytest behavior.

Mental Model

Core Idea

Conftest fixtures are shared setup helpers stored in a special file that pytest automatically finds and uses across multiple test files.

Think of it like...

Imagine a shared toolbox in a workshop corner that everyone uses instead of each worker buying their own tools. Conftest.py is that toolbox for tests, holding tools (fixtures) everyone can use.

project_root/
├── conftest.py  <-- shared fixtures here
├── test_module1.py  <-- uses fixtures from conftest.py
└── subdir/
    └── test_module2.py  <-- also uses fixtures from conftest.py

pytest automatically finds conftest.py and makes its fixtures available to all tests in the directory tree.

Build-Up - 7 Steps

1

Foundation

Basic pytest fixture concept

Concept: Learn what a fixture is and how it provides setup for tests.

A fixture is a function decorated with @pytest.fixture that prepares something your test needs, like data or a resource. Tests receive fixtures by naming them as parameters. Example: import pytest @pytest.fixture def sample_data(): return [1, 2, 3] def test_sum(sample_data): assert sum(sample_data) == 6

Result

The test passes because sample_data provides the list [1, 2, 3] to the test function.

Understanding fixtures as setup providers helps you write cleaner tests by separating preparation from assertions.

2

Foundation

Local fixture usage in one test file

Concept: Use fixtures defined in the same test file to share setup among tests.

Fixtures can be defined in the same file as tests and used by multiple tests there. Example: import pytest @pytest.fixture def user(): return {'name': 'Alice', 'age': 30} def test_name(user): assert user['name'] == 'Alice' def test_age(user): assert user['age'] == 30

Result

Both tests pass, sharing the same user fixture without repeating code.

Sharing fixtures locally avoids duplication and keeps tests consistent within a file.

3

Intermediate

Introducing conftest.py for sharing fixtures

🤔Before reading on: do you think fixtures in conftest.py must be imported explicitly in test files? Commit to your answer.

Concept: Fixtures in conftest.py are automatically discovered and shared across multiple test files without imports.

Create a file named conftest.py in your test directory and define fixtures there. Example conftest.py: import pytest @pytest.fixture def db_connection(): return 'database connection' In test files, just use the fixture by name: def test_db(db_connection): assert db_connection == 'database connection' No import of db_connection is needed.

Result

Tests in any file under the directory with conftest.py can use db_connection fixture seamlessly.

Knowing pytest auto-discovers conftest.py fixtures removes the need for manual imports, simplifying test code and encouraging reuse.

4

Intermediate

Fixture scope and sharing across directories

🤔Before reading on: do you think a fixture in conftest.py applies to tests in subdirectories by default? Commit to your answer.

Concept: Fixtures in conftest.py apply to tests in the same directory and all subdirectories unless overridden.

If you have this structure: project/ ├── conftest.py # defines fixture ├── test_a.py └── subdir/ └── test_b.py Both test_a.py and test_b.py can use fixtures from conftest.py. Fixture scope can be set to 'function', 'module', 'class', or 'session' to control lifetime.

Result

Fixtures are shared across files and folders, making setup consistent and efficient across large projects.

Understanding fixture scope and directory hierarchy helps you organize tests and fixtures for maximum reuse and minimal setup overhead.

5

Intermediate

Avoiding fixture name conflicts

🤔Before reading on: if two conftest.py files in different folders define the same fixture name, which one is used? Commit to your answer.

Concept: pytest uses the closest conftest.py fixture in the directory tree, allowing overrides by folder.

If you have: project/ ├── conftest.py # fixture 'config' └── subdir/ ├── conftest.py # fixture 'config' overrides └── test_sub.py Tests in subdir use the subdir conftest.py fixture 'config', overriding the parent. This allows customizing fixtures per folder.

Result

Fixture resolution follows directory proximity, enabling flexible fixture customization.

Knowing fixture override rules prevents confusion and helps design layered test setups.

6

Advanced

Using autouse fixtures in conftest.py

🤔Before reading on: do you think autouse fixtures run only when explicitly requested by tests? Commit to your answer.

Concept: Autouse fixtures run automatically for all tests in scope without needing to be named as parameters.

In conftest.py: import pytest @pytest.fixture(autouse=True) def setup_env(): print('Setup environment') All tests in the directory tree run setup_env before executing. This is useful for global setup like environment variables or mocks.

Result

Tests run with setup_env executed automatically, even if not requested explicitly.

Understanding autouse fixtures helps implement global test setup without cluttering test signatures.

7

Expert

Conftest fixtures and plugin integration

🤔Before reading on: can conftest.py fixtures be used to extend or customize pytest plugins? Commit to your answer.

Concept: Conftest.py can define hooks and fixtures that integrate with or extend pytest plugins, customizing test behavior deeply.

Conftest.py can include special hook functions like pytest_runtest_setup or pytest_configure to modify pytest internals. Example: def pytest_configure(config): print('Custom pytest configuration') This allows advanced control over test collection, reporting, or environment setup. Fixtures can also provide resources used by plugins.

Result

pytest behavior can be customized project-wide via conftest.py, beyond simple fixtures.

Knowing conftest.py can hook into pytest internals unlocks powerful customization for complex testing needs.

Under the Hood

pytest searches for conftest.py files starting from the test file's directory up to the root directory. It loads fixtures defined there into its fixture registry. When a test requests a fixture, pytest looks up the fixture by name in the closest conftest.py and test file fixtures, resolving overrides by directory proximity. Fixtures are cached and managed according to their scope to optimize setup and teardown.

Why designed this way?

Conftest.py was designed to avoid explicit imports and allow implicit sharing of fixtures across test files. This reduces boilerplate and encourages modular test setup. The directory-based discovery aligns with common project layouts, making fixture sharing intuitive and flexible. Alternatives like manual imports were rejected for being verbose and error-prone.

Test file
  │
  ▼
[pytest collects fixtures]
  │
  ▼
┌─────────────────────┐
│ conftest.py (closest)│
└─────────────────────┘
  │
  ▼
┌─────────────────────┐
│ conftest.py (parent) │
└─────────────────────┘
  │
  ▼
[fixture registry]
  │
  ▼
[test execution with fixtures]

Myth Busters - 4 Common Misconceptions

Quick: Do you think you must import fixtures from conftest.py in your test files? Commit to yes or no.

Common Belief: You must import fixtures from conftest.py explicitly in each test file to use them.

Reality: pytest automatically discovers and provides conftest.py fixtures to all tests in the directory tree without imports.

Why it matters: Trying to import fixtures manually leads to import errors and redundant code, defeating the purpose of conftest.py.

Quick: Do you think a fixture in conftest.py applies to tests in sibling directories? Commit to yes or no.

Common Belief: Fixtures in conftest.py apply to all tests in the project regardless of directory.

Reality: Fixtures apply only to tests in the same directory or subdirectories, not sibling directories.

Why it matters: Assuming global availability causes tests to fail unexpectedly when fixtures are not found.

Quick: Do you think autouse fixtures run only when requested by tests? Commit to yes or no.

Common Belief: Fixtures run only when explicitly requested as test parameters.

Reality: Fixtures marked autouse=True run automatically for all tests in scope, even if not requested.

Why it matters: Misunderstanding autouse can cause unexpected side effects or missed setup steps.

Quick: Do you think conftest.py is just a regular Python module you can import anywhere? Commit to yes or no.

Common Belief: conftest.py is a normal Python module that you can import in your code like any other.

Reality: conftest.py is a special pytest configuration file discovered by pytest, not meant for direct imports.

Why it matters: Trying to import conftest.py causes import errors and breaks pytest's fixture discovery.

Expert Zone

1

Fixtures in conftest.py can be layered by directory, allowing different setups for tests in subfolders without code duplication.

2

Using autouse fixtures in conftest.py can unintentionally slow down tests if expensive setup runs for every test, so scope and usage must be chosen carefully.

3

Conftest.py can define pytest hooks to customize test collection and reporting, enabling powerful project-wide test behavior changes.

When NOT to use

Avoid putting fixtures in conftest.py if they are only used by a single test file; define them locally instead to keep scope clear. For very large projects, consider pytest plugins for reusable fixtures across multiple projects. Also, avoid autouse fixtures for expensive setup unless necessary.

Production Patterns

In real projects, conftest.py often holds database connections, test data factories, and environment setup shared by many tests. Teams use layered conftest.py files to customize fixtures per feature or module. Autouse fixtures in conftest.py handle global mocks or configuration. Hooks in conftest.py customize test reporting or integrate with CI systems.

Connections

Dependency Injection

Conftest fixtures implement a form of dependency injection by providing test dependencies automatically.

Understanding conftest fixtures as dependency injection helps grasp how tests get resources without manual wiring, improving modularity.

Modular Programming

Conftest.py promotes modularity by centralizing shared setup code separate from test logic.

Recognizing conftest.py as a modular component encourages clean separation of concerns in test design.

Shared Resources in Operating Systems

Like shared libraries or services in OS that multiple programs use, conftest fixtures provide shared resources to tests.

Seeing conftest fixtures as shared system resources clarifies their role in efficient resource management across tests.

Common Pitfalls

#1 Trying to import fixtures from conftest.py in test files.

Wrong approach:

from conftest import db_connection

def test_db(db_connection):
assert db_connection == 'database connection'

Correct approach:

def test_db(db_connection):
assert db_connection == 'database connection'

Root cause:

Misunderstanding that pytest auto-discovers conftest.py fixtures and that manual imports are unnecessary and cause errors.

#2 Defining expensive setup as autouse fixture without scope control.

Wrong approach:

@pytest.fixture(autouse=True)
def setup_expensive():
print('Setup runs before every test')
# expensive setup code here

Correct approach:

@pytest.fixture(scope='session', autouse=True)
def setup_expensive():
print('Setup runs once per test session')
# expensive setup code here

Root cause:

Not setting fixture scope causes expensive setup to run before every test, slowing down the test suite.

#3 Expecting fixtures in conftest.py to be available in sibling directories.

Wrong approach:

project/
├── conftest.py # fixture 'config'
└── otherdir/
└── test_other.py # uses 'config' fixture expecting it to work

Correct approach:

Move conftest.py to a common parent directory or duplicate fixture in otherdir/conftest.py

Root cause:

Not understanding pytest fixture discovery is directory-tree based and does not cross sibling directories.

Key Takeaways

Conftest.py is a special pytest file that holds fixtures shared automatically across multiple test files in its directory and subdirectories.

pytest discovers fixtures in conftest.py without imports, simplifying test code and encouraging reuse.

Fixture scope and directory hierarchy control how and where fixtures apply, enabling flexible test setups.

Autouse fixtures in conftest.py run automatically for all tests in scope, useful for global setup but must be used carefully.

Conftest.py can also define pytest hooks for advanced customization beyond fixtures, making it a powerful tool in professional testing.

Practice

1. What is the main purpose of placing fixtures in a conftest.py file in pytest?

easy

A. To run tests in parallel automatically

B. To share setup code automatically across multiple test files without importing

C. To store test data in a database

D. To define test cases only for one specific test file

Solution

1. Step 1: Understand the role of conftest.py

   The conftest.py file is used to define fixtures that can be shared across multiple test files without needing explicit imports.

2. Step 2: Identify the purpose of sharing setup code

   Sharing setup code helps avoid repetition and makes tests cleaner and easier to maintain.

3. Final Answer:

   To share setup code automatically across multiple test files without importing -> Option B

4. Quick Check:

   conftest.py shares fixtures automatically [OK]

Hint: Remember: conftest.py shares fixtures without imports [OK]

Common Mistakes:

• Thinking conftest.py runs tests in parallel
• Believing conftest.py stores test data
• Assuming fixtures in conftest.py are for one file only

2. Which of the following is the correct way to define a fixture in conftest.py for sharing across test files?

easy

A. def my_fixture(): return 42

B. class my_fixture: pass

C. @pytest.fixture
def my_fixture(): return 42

D. import pytest
my_fixture = 42

Solution

1. Step 1: Recall fixture syntax in pytest

   Fixtures must be decorated with @pytest.fixture to be recognized by pytest.

2. Step 2: Check each option

   @pytest.fixture def my_fixture(): return 42 correctly uses the decorator and defines a function returning a value. Other options miss the decorator or use wrong syntax.

3. Final Answer:

   @pytest.fixture\ndef my_fixture(): return 42 -> Option C

4. Quick Check:

   Fixtures need @pytest.fixture decorator [OK]

Hint: Always use @pytest.fixture decorator for fixtures [OK]

Common Mistakes:

• Forgetting the @pytest.fixture decorator
• Defining fixtures as classes without decorator
• Assigning fixture values without function

3. Given the following conftest.py fixture and test file, what will be the output when running pytest?

-- conftest.py --
import pytest

@pytest.fixture
def number():
    return 5

-- test_sample.py --

def test_double(number):
    assert number * 2 == 10

def test_triple(number):
    assert number * 3 == 15

medium

A. Both tests pass

B. Both tests fail

C. test_double passes, test_triple fails

D. test_double fails, test_triple passes

Solution

1. Step 1: Understand fixture usage

   The fixture number returns 5 and is shared automatically via conftest.py.

2. Step 2: Evaluate test assertions

   test_double checks 5*2 == 10 (True), test_triple checks 5*3 == 15 (True). Both assertions are correct.

3. Final Answer:

   Both tests pass -> Option A

4. Quick Check:

   Fixture returns 5, assertions match [OK]

Hint: Check fixture value and test assertions carefully [OK]

Common Mistakes:

• Assuming fixture is not shared without import
• Miscalculating expected assertion values
• Confusing test pass/fail logic

4. You have a fixture defined in conftest.py as follows:

import pytest

@pytest.fixture
def data():
    return [1, 2, 3]

In your test file, you wrote:

def test_sum(data):
    assert sum(data) == 10

What is the problem and how to fix it?

medium

A. Assertion is wrong; sum([1,2,3]) is 6, so change 10 to 6

B. Fixture not imported; add from conftest import data

C. Fixture must be a class, not a function

D. sum() cannot be used on lists

Solution

1. Step 1: Check the fixture return value

   The fixture data returns the list [1, 2, 3].

2. Step 2: Calculate the sum and compare with assertion

   sum([1, 2, 3]) equals 6, but the test asserts it equals 10, which is incorrect.

3. Final Answer:

   Assertion is wrong; sum([1,2,3]) is 6, so change 10 to 6 -> Option A

4. Quick Check:

   sum([1,2,3]) = 6, fix assertion [OK]

Hint: Verify expected values match fixture data [OK]

Common Mistakes:

• Thinking fixture must be imported explicitly
• Assuming sum() can't handle lists
• Changing fixture type unnecessarily

5. You want to share a fixture that provides a database connection across multiple test files. You place this fixture in conftest.py:

import pytest

@pytest.fixture(scope="session")
def db_connection():
    conn = create_connection()
    yield conn
    conn.close()

What is the best reason to use scope="session" here?

hard

A. To run tests in parallel using the same connection

B. To create a new connection for every test function

C. To close the connection before each test

D. To create the connection once per test session and reuse it in all tests

Solution

1. Step 1: Understand fixture scopes in pytest

   Scope "session" means the fixture is created once for the entire test run and shared across all tests.

2. Step 2: Apply to database connection use case

   Creating the connection once saves time and resources, and closing it after all tests is efficient.

3. Final Answer:

   To create the connection once per test session and reuse it in all tests -> Option D

4. Quick Check:

   Session scope = one setup per test run [OK]

Hint: Use session scope for expensive setup reused by all tests [OK]

Common Mistakes:

• Thinking session scope creates new instance per test
• Assuming connection closes before each test
• Confusing scope with parallel test execution