Autouse fixtures in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pytest autouse fixture execution order

Consider the following pytest code with autouse fixtures. What will be the output when running the test?

PyTest

import pytest

@pytest.fixture(autouse=True)
def setup_one():
    print("Setup One")

@pytest.fixture(autouse=True)
def setup_two():
    print("Setup Two")


def test_example():
    print("Test Running")

A Test Running\nSetup Two\nSetup One

B Setup One\nSetup Two\nTest Running

C Test Running\nSetup One\nSetup Two

D Setup Two\nSetup One\nTest Running

💡 Hint

Autouse fixtures run before the test function in the order they are defined.

Pytest runs autouse fixtures in the order they appear in the code before the test function. So 'setup_one' prints first, then 'setup_two', then the test prints.

❓ assertion

intermediate

Correct assertion to verify autouse fixture effect

You have an autouse fixture that appends 'setup' to a list before each test. Which assertion correctly verifies the list contains 'setup' after the test runs?

PyTest

import pytest

results = []

@pytest.fixture(autouse=True)
def add_setup():
    results.append('setup')


def test_check():
    # Which assertion below is correct?
    pass

A assert 'setup' in results

B assert results == ['setup']

C assert results.count('setup') == 0

D assert results is None

💡 Hint

The fixture adds 'setup' to the list before each test, so the list should contain 'setup'.

Option A checks if 'setup' is in the list, which is true after the fixture runs. Option A may fail if multiple tests run and append multiple 'setup' entries. Options C and D are incorrect.

🔧 Debug

advanced

Identify why autouse fixture is not running

Given this pytest code, why does the autouse fixture not run before the test?

PyTest

import pytest

@pytest.fixture(autouse=True)
def setup():
    print("Setup running")

def test_sample():
    print("Test running")

A The fixture is defined in a different module and not imported

B The fixture is missing the @pytest.mark.usefixtures decorator

C The test function name does not start with 'test_'

D Autouse fixtures only run for class-based tests

💡 Hint

Autouse fixtures must be visible to the test, usually in the same module or conftest.py.

If the fixture is defined in another module but not imported or in conftest.py, pytest won't run it automatically. The other options are incorrect because autouse fixtures do not require @usefixtures, test name is correct, and autouse works for function tests too.

❓ framework

advanced

Behavior of autouse fixtures with different scopes

Which statement correctly describes how autouse fixtures behave with different scopes in pytest?

A Autouse fixtures cannot have 'class' scope

B An autouse fixture with 'function' scope runs once per test session

C Autouse fixtures ignore their scope and always run before each test function

D An autouse fixture with 'module' scope runs once per module before any tests

💡 Hint

Fixture scope controls how often the fixture runs, autouse controls if it runs automatically.

Autouse fixtures respect their scope. A 'module' scoped autouse fixture runs once before any tests in that module. 'Function' scope runs before each test function. Option D is wrong because 'function' scope runs per test, not per session. Option D is false because scope matters. Option D is false; autouse fixtures can have 'class' scope.

🧠 Conceptual

expert

Impact of autouse fixtures on test isolation and performance

Which of the following is the best explanation of the impact of using autouse fixtures extensively in a large pytest suite?

A Using autouse fixtures eliminates the need for explicit fixture usage and has no impact on test performance

B Autouse fixtures always speed up tests by sharing setup across all tests

C Autouse fixtures improve test isolation but may slow down the test suite if they perform expensive setup for every test

D Autouse fixtures prevent tests from running in parallel

💡 Hint

Think about how often autouse fixtures run and what they do.

Autouse fixtures run automatically before tests, which helps ensure setup runs consistently, improving isolation. However, if the fixture does expensive work and has a narrow scope like 'function', it can slow down the suite. They do not inherently speed up tests or prevent parallelism.

Practice

1. What is the main purpose of an autouse fixture in pytest?

easy

A. To run the fixture automatically for all tests without explicitly adding it as a parameter

B. To skip the fixture during test execution

C. To run the fixture only when explicitly requested in the test

D. To disable all fixtures in the test file

Solution

1. Step 1: Understand what autouse means in pytest

   An autouse fixture runs automatically for every test in its scope without needing to be listed as a parameter.

2. Step 2: Compare options with this behavior

   Only To run the fixture automatically for all tests without explicitly adding it as a parameter describes this automatic running behavior correctly.

3. Final Answer:

   To run the fixture automatically for all tests without explicitly adding it as a parameter -> Option A

4. Quick Check:

   Autouse = automatic run without listing [OK]

Hint: Autouse means automatic use without listing in test [OK]

Common Mistakes:

• Thinking autouse disables the fixture
• Believing autouse requires explicit test parameters
• Confusing autouse with skipping tests

2. Which of the following is the correct way to declare an autouse fixture in pytest?

easy

A. @pytest.fixture(auto=True)
def setup():
pass

B. @pytest.fixture(autouse=True)
def setup():
pass

C. @pytest.autouse()
def setup():
pass

D. @pytest.usefixture(autouse=True)
def setup():
pass

Solution

1. Step 1: Recall correct syntax for autouse fixture

   The correct decorator is @pytest.fixture with the argument autouse=True.

2. Step 2: Check each option's syntax

   Only @pytest.fixture(autouse=True) def setup(): pass uses @pytest.fixture(autouse=True) correctly. Others use invalid decorators or wrong argument names.

3. Final Answer:

   @pytest.fixture(autouse=True) def setup(): pass -> Option B

4. Quick Check:

   Use @pytest.fixture(autouse=True) for autouse [OK]

Hint: Remember: autouse is a parameter in @pytest.fixture [OK]

Common Mistakes:

• Using @pytest.autouse decorator which does not exist
• Writing autouse as auto=True
• Using @pytest.usefixture instead of @pytest.fixture

3. Given the code below, what will be the output when running pytest?

import pytest

@pytest.fixture(autouse=True)
def setup():
    print('Setup runs')


def test_one():
    print('Test one running')


def test_two():
    print('Test two running')

medium

A. Test one running\nTest two running

B. Setup runs\nSetup runs\nTest one running\nTest two running

C. Setup runs\nTest one running\nSetup runs\nTest two running

D. Setup runs\nTest one running\nTest two running

Solution

1. Step 1: Understand autouse fixture behavior

   The autouse fixture runs automatically before each test function in the module.

2. Step 2: Trace the print statements during test runs

   For test_one: 'Setup runs' then 'Test one running'. For test_two: 'Setup runs' then 'Test two running'.

3. Final Answer:

   Setup runs\nTest one running\nSetup runs\nTest two running -> Option C

4. Quick Check:

   Autouse runs before each test = output B [OK]

Hint: Autouse fixture runs before every test automatically [OK]

Common Mistakes:

• Assuming fixture runs only once
• Ignoring print inside fixture
• Thinking tests run without setup prints

4. What is wrong with the following autouse fixture code?

import pytest

@pytest.fixture(autouse=True)
def setup():
    print('Setup')

@pytest.fixture
def test_data():
    return 42


def test_example(test_data):
    assert test_data == 42

medium

A. There is no error; the code works correctly

B. The test_data fixture cannot be used with autouse fixtures

C. The autouse fixture setup() does not yield or return, so cleanup is impossible

D. The autouse fixture setup() must accept a parameter

Solution

1. Step 1: Review fixture definitions and usage

   setup() is an autouse fixture that runs automatically and prints 'Setup'. test_data() is a normal fixture returning 42.

2. Step 2: Check if any syntax or usage errors exist

   Both fixtures are valid. Autouse fixtures do not need parameters or yield unless cleanup is needed. test_example uses test_data correctly.

3. Final Answer:

   There is no error; the code works correctly -> Option A

4. Quick Check:

   Autouse fixture without yield is valid [OK]

Hint: Autouse fixtures can be simple setup without yield [OK]

Common Mistakes:

• Expecting autouse fixtures must yield for cleanup
• Thinking autouse conflicts with other fixtures
• Assuming autouse fixtures need parameters

5. You want an autouse fixture to run once per test class, not before every test method. Which scope value should you use with @pytest.fixture(autouse=True)?

hard

A. "session"

B. "module"

C. "function"

D. "class"

Solution

1. Step 1: Understand pytest fixture scopes

   Scope "function" runs before each test function, "class" runs once per test class, "module" once per module, "session" once per test session.

2. Step 2: Match desired behavior to scope

   To run once per test class, use scope="class" with autouse=True.

3. Final Answer:

   "class" -> Option D

4. Quick Check:

   Scope "class" runs once per test class [OK]

Hint: Use scope='class' for autouse fixture once per test class [OK]

Common Mistakes:

• Using default scope 'function' which runs before every test
• Confusing 'module' with 'class' scope
• Using 'session' which runs too broadly