Handling shared resources in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a fixture that sets up a shared resource.

PyTest

import pytest

@pytest.fixture
 def shared_resource():
     resource = {'count': 0}
     yield resource
     resource.clear()

def test_increment(shared_resource):
     shared_resource['count'] [1] 1
     assert shared_resource['count'] == 1

Drag options to blanks, or click blank then click option'

A+=

B-=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-=' decreases the count, causing the test to fail.

Using '*=' or '/=' changes the count incorrectly.

The '+=' operator increments the count by 1, which matches the assertion.

2fill in blank

medium

Complete the code to ensure the shared resource is reset before each test.

PyTest

import pytest

@pytest.fixture(autouse=True)
 def reset_resource(shared_resource):
     shared_resource['count'] = [1]

def test_reset(shared_resource):
     assert shared_resource['count'] == 0

Drag options to blanks, or click blank then click option'

A1

B-1

C0

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Setting count to 1 causes the test to fail because the assertion expects 0.

Setting count to None or negative values is not appropriate here.

Resetting the count to 0 ensures the shared resource starts fresh for each test.

3fill in blank

hard

Fix the error in the test that modifies the shared resource incorrectly.

PyTest

def test_decrement(shared_resource):
     shared_resource['count'] [1] 1
     assert shared_resource['count'] == -1

Drag options to blanks, or click blank then click option'

A+=

B-=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+=' increases the count, causing the assertion to fail.

Using '*=' or '/=' changes the value incorrectly.

Using '-=' decreases the count by 1, matching the expected assertion of -1.

4fill in blank

hard

Fill both blanks to create a fixture that yields a resource and cleans it after use.

PyTest

import pytest

@pytest.fixture
 def resource():
     data = []
     yield [1]
     [2].clear()

Drag options to blanks, or click blank then click option'

Adata

Bresource

Attempts:

3 left

💡 Hint

Common Mistakes

Yielding or clearing a variable not defined causes errors.

Using different variable names for yield and clear breaks the cleanup.

The fixture yields 'data' and then clears 'data' after the test finishes.

5fill in blank

hard

Fill all three blanks to create a test that uses a shared resource and asserts its state.

PyTest

def test_shared_state([1]):
     [2]['count'] += 2
     assert [3]['count'] == 2

Drag options to blanks, or click blank then click option'

Ashared_resource

Dresource

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names causes NameError or test failures.

Referencing undefined variables breaks the test.

The test function parameter and all references use 'shared_resource' to access the shared data.

Practice

1. What is the main purpose of using shared resources in pytest tests?

easy

A. To make tests run slower by adding extra steps

B. To reuse setup work and avoid conflicts between tests

C. To write tests without any setup or teardown

D. To skip tests that use external files

Solution

1. Step 1: Understand shared resources in testing

   Shared resources allow multiple tests to use the same setup, saving time and avoiding repeated work.

2. Step 2: Recognize the benefit of avoiding conflicts

   Using shared resources carefully prevents tests from interfering with each other, keeping results reliable.

3. Final Answer:

   To reuse setup work and avoid conflicts between tests -> Option B

4. Quick Check:

   Shared resources = reuse setup + avoid conflicts [OK]

Hint: Shared resources save setup time and prevent test clashes [OK]

Common Mistakes:

• Thinking shared resources slow tests down
• Believing shared resources remove the need for setup
• Confusing shared resources with skipping tests

2. Which pytest fixture scope is best to share a resource across all tests in a module?

easy

A. "function" scope

B. "class" scope

C. "session" scope

D. "module" scope

Solution

1. Step 1: Recall pytest fixture scopes

   "function" runs for each test, "class" for each test class, "module" for all tests in a file, "session" for all tests in a run.

2. Step 2: Identify scope for sharing in a module

   To share a resource across all tests in one module (file), use "module" scope.

3. Final Answer:

   "module" scope -> Option D

4. Quick Check:

   Module scope = share resource in one file [OK]

Hint: "module" scope shares resource across one test file [OK]

Common Mistakes:

• Using "function" scope which creates resource per test
• Choosing "class" scope which limits sharing to test classes
• Confusing "session" scope which shares across all tests

3. What will be the output of this pytest fixture usage?

import pytest

@pytest.fixture(scope="module")
def resource():
    print("Setup resource")
    yield "data"
    print("Teardown resource")

def test_one(resource):
    assert resource == "data"

def test_two(resource):
    assert resource == "data"

medium

A. Setup resource printed once, then tests pass, then Teardown resource printed once

B. Setup resource and Teardown resource printed before each test

C. Setup resource printed twice, no teardown printed

D. No output printed because print statements are ignored

Solution

1. Step 1: Understand fixture scope and yield behavior

   With "module" scope, setup runs once before all tests in the module, yield provides the resource, and teardown runs once after all tests.

2. Step 2: Analyze print outputs during test run

   "Setup resource" prints once before tests, both tests use the resource and pass, then "Teardown resource" prints once after all tests.

3. Final Answer:

   Setup resource printed once, then tests pass, then Teardown resource printed once -> Option A

4. Quick Check:

   Module scope fixture setup/teardown run once [OK]

Hint: Module scope fixture setup/teardown run once per module [OK]

Common Mistakes:

• Expecting setup/teardown to run before and after each test
• Thinking print statements are suppressed
• Confusing fixture scope with function scope

4. Identify the error in this pytest fixture that shares a database connection:

@pytest.fixture(scope="module")
def db_connection():
    conn = open_db()
    yield conn
    conn.close()

def test_query(db_connection):
    assert db_connection.execute("SELECT 1") == 1

def test_insert(db_connection):
    db_connection.execute("INSERT INTO table VALUES (1)")

medium

A. The connection might be shared but not reset between tests causing side effects

B. The fixture does not close the connection after tests

C. The fixture scope should be "function" to avoid conflicts

D. The yield statement is missing in the fixture

Solution

1. Step 1: Review fixture setup and teardown

   The fixture opens a connection, yields it, then closes it after all tests in the module.

2. Step 2: Consider side effects of shared connection

   Because the connection is shared and not reset between tests, changes in one test (like insert) may affect others, causing flaky tests.

3. Final Answer:

   The connection might be shared but not reset between tests causing side effects -> Option A

4. Quick Check:

   Shared resource without reset risks test interference [OK]

Hint: Shared resources need reset or isolation to avoid side effects [OK]

Common Mistakes:

• Thinking connection is never closed
• Assuming function scope is always required
• Missing yield statement in fixture

5. You want to share a temporary folder between tests but ensure it is empty before each test. Which pytest fixture setup is best?

hard

A. Use a "module" scoped fixture that creates the folder once and clears it before each test

B. Use a "session" scoped fixture that creates the folder once and never cleans it

C. Use a "function" scoped fixture that creates and deletes the folder for each test

D. Use a "class" scoped fixture that creates the folder once per test class without cleanup

Solution

1. Step 1: Understand the need to share and clean resource

   You want to share the folder to save setup time but also ensure it is empty before each test to avoid leftover files.

2. Step 2: Choose fixture scope and cleanup strategy

   A "function" scoped fixture creates and deletes the folder for each test, ensuring it is empty before each test and avoiding leftover files.

3. Final Answer:

   Use a "function" scoped fixture that creates and deletes the folder for each test -> Option C

4. Quick Check:

   Function scope fixture creates clean folder per test [OK]

Hint: Create and delete resource per test for clean state [OK]

Common Mistakes:

• Using function scope causing slow tests
• Using session scope without cleanup causing test pollution
• Using class scope which limits sharing incorrectly