Ordering tests for parallel safety in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is test ordering important in parallel test execution?

When running tests in parallel, why must the order of tests be carefully managed?

A Because parallel tests cannot run on multiple CPUs without ordering.

B Because parallel tests always run slower if ordered incorrectly.

C Because tests may share state or resources, causing failures if run simultaneously without order.

D Because test order affects the syntax of test code.

💡 Hint

Think about what happens if two tests change the same file or database at the same time.

Tests that share resources or state can interfere with each other if run simultaneously. Proper ordering or isolation prevents flaky failures.

❓ Predict Output

intermediate

Output of pytest with parallel tests sharing a file

Given the following pytest code where two tests write to the same file without synchronization, what is the likely outcome when run with pytest-xdist parallel execution?

PyTest

import pytest

@pytest.mark.parametrize('content', ['A', 'B'])
def test_write_file(tmp_path, content):
    file = tmp_path / 'shared.txt'
    with open(file, 'a') as f:
        f.write(content)
    with open(file) as f:
        data = f.read()
    assert content in data

A Tests will run sequentially ignoring parallel execution.

B Tests will always pass because each test writes different content.

C Tests will raise a SyntaxError due to invalid file operations.

D Tests may fail intermittently due to race conditions writing to the same file.

💡 Hint

Consider what happens if two tests append to the same file at the same time.

Appending to the same file concurrently can cause race conditions, leading to unpredictable file content and test failures.

❓ assertion

advanced

Correct assertion to verify test isolation in parallel runs

Which assertion best verifies that a test run in parallel does not affect the shared resource state?

PyTest

def test_resource_isolation(shared_resource):
    # shared_resource is reset before each test
    shared_resource.modify('test')
    # What assertion ensures isolation?

A assert shared_resource.state == 'initial'

B assert shared_resource.state == 'test'

C assert shared_resource is None

D assert shared_resource.state != 'initial'

💡 Hint

Isolation means the resource state should be fresh at test start.

To confirm isolation, the resource state should be the initial state before modification, ensuring no leftover changes from other tests.

🔧 Debug

advanced

Identify the cause of flaky tests in parallel pytest runs

Given this pytest code snippet, tests sometimes fail when run with pytest-xdist. What is the most likely cause?

PyTest

import pytest

shared_counter = 0

def increment():
    global shared_counter
    temp = shared_counter
    temp += 1
    shared_counter = temp

@pytest.mark.parametrize('n', range(5))
def test_increment(n):
    increment()
    assert shared_counter >= n + 1

A Incorrect assertion logic causing always failing tests.

B Race condition on shared_counter causing inconsistent increments.

C Syntax error in the increment function.

D pytest-xdist disables global variables automatically.

💡 Hint

Think about what happens when multiple tests update the same variable at the same time.

Multiple tests incrementing a shared variable without locks cause race conditions, leading to flaky test results.

❓ framework

expert

Best pytest fixture scope for parallel test isolation

Which pytest fixture scope ensures each parallel test worker gets its own fresh resource instance, preventing cross-test interference?

A scope='function'

B scope='module'

C scope='session'

D scope='package'

💡 Hint

Consider which scope creates a new fixture instance for every test function.

The 'function' scope creates a new fixture instance for each test function, ensuring isolation in parallel runs. Other scopes share instances across multiple tests, risking interference.