Running with -n auto in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output when running pytest with '-n auto' on this test file?

Given this simple pytest test file, what will be the output when running pytest -n auto?

PyTest

import pytest
import time

def test_one():
    time.sleep(1)
    assert True

def test_two():
    time.sleep(1)
    assert True

def test_three():
    time.sleep(1)
    assert True

A Tests run in parallel but fail due to shared state issues.

B All tests run sequentially taking about 3 seconds total, all pass.

C Tests run in parallel, total time about 1 second, all pass.

D Tests run sequentially but fail due to missing dependencies.

💡 Hint

Think about how -n auto uses all CPU cores to run tests in parallel.

The -n auto option runs tests in parallel using all available CPU cores. Since each test sleeps 1 second, running three tests sequentially would take about 3 seconds. Running in parallel reduces total time to about 1 second. There is no shared state causing failure here.

❓ assertion

intermediate

Which assertion correctly verifies pytest-xdist runs tests in parallel?

You want to write a test that checks if pytest-xdist is running tests in parallel using -n auto. Which assertion is correct?

PyTest

import pytest
import time
import threading

results = []

def test_parallel():
    def worker():
        time.sleep(1)
        results.append(threading.get_ident())

    threads = []
    for _ in range(3):
        t = threading.Thread(target=worker)
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

    # Which assertion below correctly checks parallel execution?

A assert results == []

B assert len(results) == 1

C assert all(r == results[0] for r in results)

D assert len(set(results)) == 3

💡 Hint

Parallel execution means different threads run the tasks.

If tests run in parallel, the worker function runs in different threads, so threading.get_ident() returns different thread IDs. Checking that the set of thread IDs has length 3 confirms parallelism.

🔧 Debug

advanced

Why does pytest with '-n auto' fail on tests using a global variable?

Consider this test file:

counter = 0

def test_increment():
    global counter
    counter += 1
    assert counter == 1

When running pytest -n auto, tests fail intermittently. Why?

A Because tests run in separate processes, global variables are not shared, causing inconsistent state.

B Because <code>-n auto</code> disables global variables.

C Because pytest-xdist requires tests to be synchronous.

D Because the global variable is reset by pytest before each test.

💡 Hint

Think about how pytest-xdist runs tests in parallel processes.

Pytest-xdist runs tests in separate processes. Each process has its own memory space, so global variables are not shared. Incrementing a global variable in one process does not affect others, causing the assertion to fail.

❓ framework

advanced

Which pytest plugin enables the '-n auto' option for parallel test execution?

You want to run tests in parallel using pytest -n auto. Which plugin must be installed?

A pytest-xdist

B pytest-parallel

C pytest-concurrent

D pytest-multithread

💡 Hint

Look for the official pytest plugin that supports -n option.

The pytest-xdist plugin provides the -n option to run tests in parallel across multiple CPUs.

🧠 Conceptual

expert

What is a key limitation when using 'pytest -n auto' with tests that modify a database?

When running tests with pytest -n auto that modify a shared database, what is a common limitation?

A Tests automatically rollback changes after each test.

B Tests may interfere with each other causing flaky results due to concurrent writes.

C Tests cannot access the database at all when run in parallel.

D Tests run slower because database connections are serialized.

💡 Hint

Think about shared resources and concurrency.

Running tests in parallel that modify the same database can cause race conditions and flaky tests because multiple tests write concurrently without isolation.