Avoiding test interdependence in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why avoid test interdependence?

In pytest, why is it important to avoid test interdependence?

A Because dependent tests can cause false failures if one test fails, affecting others.

B Because pytest does not allow tests to share any data or fixtures.

C Because interdependent tests run slower than independent tests.

D Because tests that depend on each other cannot be run in parallel.

💡 Hint

Think about what happens if one test fails and others rely on it.

Tests that depend on each other can cause cascading failures, making it hard to find the real problem. Independent tests help isolate issues.

❓ Predict Output

intermediate

Output of pytest with interdependent tests

What will be the output status of the second test when running pytest on this code?

PyTest

shared_list = []

def test_add_item():
    shared_list.append(1)
    assert len(shared_list) == 1

def test_check_item():
    assert shared_list == [1]

A First test fails, second test passes

B First test passes, second test fails

C Both tests pass

D Both tests fail

💡 Hint

Consider the order pytest runs tests and the shared state.

Because test_add_item runs first and adds 1 to shared_list, test_check_item sees [1] and passes. But this creates interdependence on test order.

❓ assertion

advanced

Correct assertion to avoid interdependence

Which assertion best avoids test interdependence by ensuring each test starts with a clean state?

PyTest

import pytest

@pytest.fixture(autouse=True)
def clear_list():
    global shared_list
    shared_list = []

shared_list = []

def test_one():
    shared_list.append(5)
    # Assertion here

def test_two():
    # Assertion here

A assert shared_list == [5] in test_one and assert shared_list == [] in test_two

B assert len(shared_list) == 0 in both tests

C assert shared_list == [5] in both tests

D assert len(shared_list) > 0 in both tests

💡 Hint

Think about what the fixture does before each test.

The fixture resets shared_list to empty before each test. test_one adds 5, so it expects [5]. test_two expects empty list because fixture cleared it.

🔧 Debug

advanced

Identify the cause of test interdependence

Given these pytest tests, why might test_b fail if run alone?

PyTest

shared_counter = 0

def test_a():
    global shared_counter
    shared_counter += 1
    assert shared_counter == 1

def test_b():
    assert shared_counter == 1

A Because shared_counter is reset to 0 before each test automatically.

B Because test_b depends on test_a to run first and modify shared_counter.

C Because test_b modifies shared_counter before asserting.

D Because pytest runs tests in parallel causing race conditions.

💡 Hint

Think about the initial value of shared_counter and test order.

test_b expects shared_counter to be 1, but if run alone, shared_counter is 0. This shows test_b depends on test_a's side effect.

❓ framework

expert

Best pytest practice to avoid test interdependence

Which pytest feature is best to ensure tests do not share state and remain independent?

A Running tests in a fixed order to maintain state consistency

B Using global variables to share data between tests

C Disabling pytest's test isolation features for faster runs

D Using fixtures with scope='function' to provide fresh data for each test

💡 Hint

Think about how pytest can reset or provide fresh data for each test.

Fixtures with function scope run before each test, giving a clean state and avoiding interdependence. Global variables and fixed order cause dependencies.

Practice

1. Why is it important to avoid test interdependence in pytest?

easy

A. To ensure each test runs independently and results are reliable

B. To make tests run faster by sharing data

C. To reduce the number of test functions needed

D. To allow tests to modify global variables freely

Solution

1. Step 1: Understand test independence

   Tests should not rely on each other to avoid hidden bugs and unclear results.

2. Step 2: Identify the benefit of independence

   Independent tests ensure that a failure in one test does not affect others, making debugging easier.

3. Final Answer:

   To ensure each test runs independently and results are reliable -> Option A

4. Quick Check:

   Test independence = Reliable results [OK]

Hint: Tests must run alone to keep results clear and reliable [OK]

Common Mistakes:

• Thinking tests should share data to run faster
• Believing test order does not matter
• Allowing tests to modify shared global state

2. Which pytest feature helps to avoid test interdependence by preparing fresh data for each test?

easy

A. Using print statements for debugging

B. Using global variables

C. Using fixtures with scope='function'

D. Using assert statements inside tests

Solution

1. Step 1: Identify pytest features for setup

   Fixtures with scope='function' run before each test, providing fresh data.

2. Step 2: Understand why this avoids interdependence

   Fresh data per test prevents tests from affecting each other through shared state.

3. Final Answer:

   Using fixtures with scope='function' -> Option C

4. Quick Check:

   Fixtures with function scope = Fresh data each test [OK]

Hint: Use function-scoped fixtures to reset data per test [OK]

Common Mistakes:

• Using global variables which cause shared state
• Confusing print statements with setup tools
• Thinking assert statements control test independence

3. Given the following pytest code, what will be the output when running both tests?

shared_list = []

def test_add_one():
    shared_list.append(1)
    assert shared_list == [1]

def test_add_two():
    shared_list.append(2)
    assert shared_list == [2]

medium

A. Both tests pass

B. Both tests fail

C. test_add_one fails, test_add_two passes

D. test_add_one passes, test_add_two fails

Solution

1. Step 1: Analyze shared_list state across tests

   shared_list is global and not reset, so after test_add_one it contains [1].

2. Step 2: Check assertions in each test

   test_add_one expects [1] and passes; test_add_two appends 2 making list [1,2], but asserts [2], so it fails.

3. Final Answer:

   test_add_one passes, test_add_two fails -> Option D

4. Quick Check:

   Shared state causes second test failure [OK]

Hint: Global mutable state causes test failures due to leftover data [OK]

Common Mistakes:

• Assuming shared_list resets automatically
• Ignoring order of test execution
• Expecting both tests to pass with shared state

4. Identify the problem in this pytest code that causes test interdependence:

data = {}

def test_set_value():
    data['key'] = 'value'
    assert data['key'] == 'value'

def test_check_empty():
    assert data == {}

medium

A. Using dict instead of list causes errors

B. data dictionary is not reset between tests

C. Tests are missing return statements

D. Assertions are incorrect syntax

Solution

1. Step 1: Examine shared data usage

   data is a global dictionary modified in test_set_value and not cleared before test_check_empty.

2. Step 2: Understand test impact

   test_check_empty expects data to be empty, but it contains {'key': 'value'}, causing failure and interdependence.

3. Final Answer:

   data dictionary is not reset between tests -> Option B

4. Quick Check:

   Shared mutable dict causes test dependency [OK]

Hint: Reset shared data to avoid tests affecting each other [OK]

Common Mistakes:

• Thinking assertions syntax is wrong
• Believing return statements are needed in tests
• Confusing data types with test independence

5. You want to avoid test interdependence in pytest when multiple tests modify a shared database. Which approach is best?

hard

A. Use a fixture that creates a fresh database for each test and cleans up after

B. Share one database instance and reset it manually in one test only

C. Run tests in a specific order so dependencies are met

D. Use global variables to track database state across tests

Solution

1. Step 1: Understand best practice for shared resources

   Creating a fresh database per test ensures no leftover data affects other tests.

2. Step 2: Evaluate other options

   Sharing one instance with manual reset or relying on test order causes hidden dependencies and fragile tests.

3. Final Answer:

   Use a fixture that creates a fresh database for each test and cleans up after -> Option A

4. Quick Check:

   Fresh resource per test = No interdependence [OK]

Hint: Fresh setup and cleanup per test avoids hidden dependencies [OK]

Common Mistakes:

• Relying on test order which is unreliable
• Using global variables causing shared state bugs
• Resetting shared state in only one test