Fixture scope (function, class, module, session) in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pytest fixture with function scope

What will be the output count of the fixture usage in the following pytest code?

PyTest

import pytest

count = 0

@pytest.fixture(scope='function')
def my_fixture():
    global count
    count += 1
    return count

def test_one(my_fixture):
    assert my_fixture == 1

def test_two(my_fixture):
    assert my_fixture == 2

A Both tests fail due to fixture scope error

B Both tests pass; count remains 1

C First test passes; second test fails due to count being 1

D Both tests pass; count increments to 2

💡 Hint

Function scope means fixture runs fresh for each test function.

With function scope, the fixture runs separately for each test function, so count increments each time. The first test gets count=1, the second gets count=2.

❓ Predict Output

intermediate

Effect of class scope on fixture invocation count

Given this pytest code, what is the value of count after running all tests?

PyTest

import pytest

count = 0

@pytest.fixture(scope='class')
def my_fixture():
    global count
    count += 1
    return count

class TestClass:
    def test_one(self, my_fixture):
        assert my_fixture == 1

    def test_two(self, my_fixture):
        assert my_fixture == 1

A count is 1 after tests run

B Tests fail due to fixture scope mismatch

C count is 2 after tests run

D count is 0 after tests run

💡 Hint

Class scope means fixture runs once per test class.

With class scope, the fixture runs once for the entire TestClass, so count increments only once. Both tests get the same fixture value 1.

❓ assertion

advanced

Correct assertion for module scoped fixture reuse

Which assertion correctly verifies that a module scoped fixture is reused across multiple test functions?

PyTest

import pytest

@pytest.fixture(scope='module')
def resource():
    return []

def test_append_one(resource):
    resource.append(1)
    # What assertion here?

def test_append_two(resource):
    resource.append(2)
    # What assertion here?

A assert resource == [1] in test_append_one and [1, 2] in test_append_two

B assert resource == [1] in test_append_one and [2] in test_append_two

C assert resource == [1] in test_append_one and resource == [1, 2] in test_append_two

D assert resource == [1] in test_append_one and resource == [2] in test_append_two

💡 Hint

Module scope means the same fixture instance is shared across tests in the module.

The module scoped fixture returns the same list instance for both tests. After first test, list is [1]. After second test, list is [1, 2]. So assertions must reflect that.

🔧 Debug

advanced

Debugging session scoped fixture with side effects

Why does this session scoped fixture cause tests to fail intermittently?

PyTest

import pytest

@pytest.fixture(scope='session')
def db_connection():
    conn = open_db_connection()
    yield conn
    conn.close()

def test_query_one(db_connection):
    assert db_connection.query('SELECT 1') == 1

def test_query_two(db_connection):
    assert db_connection.query('SELECT 2') == 2

A The fixture is recreated for each test, causing conflicts.

B The fixture closes the connection after the first test, so second test uses closed connection.

C The fixture scope should be 'function' to avoid sharing.

D The fixture does not yield the connection properly, causing NoneType errors.

💡 Hint

Session scope means fixture runs once per test session, but teardown happens after all tests.

The fixture yields the connection once per session, but if the connection is closed too early (e.g., after first test), subsequent tests fail. Proper use of yield ensures teardown after all tests.

🧠 Conceptual

expert

Choosing fixture scope for expensive setup with multiple test classes

You have an expensive setup step needed for multiple test classes in a module. You want to run it only once per module but ensure each test class gets a fresh state derived from that setup. Which fixture scope strategy is best?

A Use a module scoped fixture for the expensive setup, then a class scoped fixture that depends on it to provide fresh state per class.

B Use a session scoped fixture for the setup and share the same state across all classes.

C Use function scoped fixtures only to ensure fresh state for every test.

D Use class scoped fixture for setup and module scoped fixture for state to optimize reuse.

💡 Hint

Think about separating expensive setup from per-class state initialization.

A module scoped fixture runs once for the expensive setup. A class scoped fixture can depend on it and create fresh state for each test class, balancing efficiency and isolation.

Practice

1. What does the function scope mean for a pytest fixture?

easy

A. The fixture runs once per entire test session.

B. The fixture runs once per test class.

C. The fixture runs once per test module.

D. The fixture runs once per test function.

Solution

1. Step 1: Understand fixture scopes

   Pytest fixtures can have different scopes controlling how often they run.

2. Step 2: Define function scope meaning

   Function scope means the fixture runs before each test function and tears down after it.

3. Final Answer:

   The fixture runs once per test function. -> Option D

4. Quick Check:

   function scope = runs per test function [OK]

Hint: Function scope means run before every test function [OK]

Common Mistakes:

• Confusing function scope with class or module scope
• Thinking function scope runs once per class
• Assuming function scope runs once per session

2. Which of the following is the correct way to set a pytest fixture with module scope?

easy

A. @pytest.fixture(scope='module')

B. @pytest.fixture(scope='function')

C. @pytest.fixture(scope='class')

D. @pytest.fixture(scope='session')

Solution

1. Step 1: Recall fixture scope syntax

   To set a fixture scope, use @pytest.fixture(scope='scope_name').

2. Step 2: Match scope name for module

   The correct scope name for module is 'module'.

3. Final Answer:

   @pytest.fixture(scope='module') -> Option A

4. Quick Check:

   module scope syntax = scope='module' [OK]

Hint: Use scope='module' to run fixture once per file [OK]

Common Mistakes:

• Using 'session' instead of 'module' for module scope
• Forgetting to add scope parameter
• Using incorrect quotes or misspelling scope

3. Given this pytest code snippet, how many times will setup_db run?

import pytest

@pytest.fixture(scope='class')
def setup_db():
    print('Setup DB')

class TestA:
    def test_1(self, setup_db):
        pass
    def test_2(self, setup_db):
        pass

class TestB:
    def test_3(self, setup_db):
        pass

medium

A. 1 time

B. 3 times

C. 2 times

D. 4 times

Solution

1. Step 1: Understand class scope behavior

   Fixture with class scope runs once per test class, before any tests in that class.

2. Step 2: Count test classes using the fixture

   There are two test classes: TestA and TestB, each uses setup_db fixture.

3. Step 3: Calculate total runs

   setup_db runs once for TestA and once for TestB, total 2 times.

4. Final Answer:

   2 times -> Option C

5. Quick Check:

   class scope = once per class, 2 classes = 2 runs [OK]

Hint: Class scope runs once per test class [OK]

Common Mistakes:

• Counting runs per test method instead of per class
• Confusing class scope with function scope
• Ignoring multiple test classes

4. Identify the error in this pytest fixture usage:

import pytest

@pytest.fixture(scope='modul')
def setup_env():
    pass

def test_example(setup_env):
    assert True

medium

A. Missing @pytest.mark.usefixtures decorator.

B. Typo in scope value causes fixture not to run.

C. Fixture function must return a value.

D. Test function missing parentheses.

Solution

1. Step 1: Check fixture scope spelling

   The scope value 'modul' is misspelled; correct is 'module'.

2. Step 2: Understand effect of typo

   Pytest will not recognize the scope and may default or error, causing fixture not to run properly.

3. Final Answer:

   Typo in scope value causes fixture not to run. -> Option B

4. Quick Check:

   Scope must be spelled correctly [OK]

Hint: Check scope spelling carefully to avoid errors [OK]

Common Mistakes:

• Assuming fixture must return a value
• Confusing fixture decorator with marker
• Ignoring spelling errors in parameters

5. You want a pytest fixture to initialize a database connection once before all tests in multiple modules run, and close it after all tests finish. Which scope should you use and why?

hard

A. Use session scope to share across all tests in the run.

B. Use function scope to isolate each test.

C. Use module scope to share per file.

D. Use class scope to share per test class.

Solution

1. Step 1: Understand the requirement

   The database connection should be initialized once before all tests in multiple modules and closed after all tests.

2. Step 2: Match scope to requirement

   Session scope runs once per entire test session, perfect for setup/teardown across all modules.

3. Final Answer:

   Use session scope to share across all tests in the run. -> Option A

4. Quick Check:

   Session scope = once per test run [OK]

Hint: Session scope runs once for all tests in the run [OK]

Common Mistakes:

• Choosing function or class scope which run too often
• Using module scope which limits to one file
• Not matching scope to resource lifetime