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.

Practice

1. What does running pytest -n auto do?

easy

A. Runs tests but disables all plugins

B. Runs tests one by one in the order they appear

C. Runs tests in parallel using all CPU cores automatically

D. Runs tests only on a single CPU core

Solution

1. Step 1: Understand the -n auto option

   The -n auto option tells pytest to run tests in parallel using all available CPU cores automatically.

2. Step 2: Compare with other options

   Running tests one by one or on a single core does not use parallelism. Disabling plugins is unrelated.

3. Final Answer:

   Runs tests in parallel using all CPU cores automatically -> Option C

4. Quick Check:

   -n auto means parallel on all cores [OK]

Hint: Remember: -n auto means use all CPU cores [OK]

Common Mistakes:

• Thinking -n auto runs tests sequentially
• Confusing -n auto with disabling plugins
• Assuming it runs on a single core only

2. Which command correctly runs pytest with parallel execution using all CPU cores?

easy

A. pytest -n all

B. pytest -n auto

C. pytest --parallel

D. pytest -p auto

Solution

1. Step 1: Identify the correct syntax for parallel execution

   The correct pytest command to run tests in parallel on all CPU cores is pytest -n auto.

2. Step 2: Check other options for correctness

   -n all is invalid, --parallel is not a pytest option, and -p auto relates to plugins, not parallelism.

3. Final Answer:

   pytest -n auto -> Option B

4. Quick Check:

   Correct flag for parallel is -n auto [OK]

Hint: Use -n auto exactly for parallel runs [OK]

Common Mistakes:

• Using -n all instead of -n auto
• Confusing plugin flags with parallel flags
• Assuming --parallel is valid

3. Given this pytest command: pytest -n auto on a machine with 4 CPU cores, what is the expected behavior?

medium

A. Tests run in parallel on 4 cores

B. Tests run sequentially on one core

C. Tests run in parallel but limited to 2 cores

D. Tests fail to run without extra flags

Solution

1. Step 1: Understand -n auto behavior

   The -n auto option uses all available CPU cores for parallel test execution.

2. Step 2: Apply to 4-core machine

   On a machine with 4 CPU cores, pytest will run tests in parallel using all 4 cores.

3. Final Answer:

   Tests run in parallel on 4 cores -> Option A

4. Quick Check:

   -n auto uses all cores = 4 cores [OK]

Hint: All cores used equals number of CPU cores [OK]

Common Mistakes:

• Assuming -n auto limits cores to 2
• Thinking tests run sequentially despite -n auto
• Believing extra flags are needed for parallelism

4. You run pytest -n auto but get an error saying the option is unknown. What is the most likely cause?

medium

A. Your Python version is too new

B. You typed -n auto incorrectly

C. You need to run pytest as administrator

D. pytest-xdist plugin is not installed

Solution

1. Step 1: Identify why -n auto might be unknown

   The -n option is provided by the pytest-xdist plugin. If it's missing, pytest won't recognize -n auto.

2. Step 2: Check other options

   Typing errors would cause different errors, Python version usually doesn't block this, and admin rights are not required.

3. Final Answer:

   pytest-xdist plugin is not installed -> Option D

4. Quick Check:

   Missing plugin causes unknown -n error [OK]

Hint: Install pytest-xdist to enable -n option [OK]

Common Mistakes:

• Ignoring plugin requirement
• Assuming Python version blocks -n
• Thinking admin rights are needed

5. You want to speed up your test suite with pytest -n auto, but some tests fail due to shared resource conflicts. What is the best approach to fix this?

hard

A. Mark conflicting tests with @pytest.mark.serial and run others in parallel

B. Remove -n auto and run all tests sequentially

C. Increase CPU cores to avoid conflicts

D. Disable pytest-xdist plugin

Solution

1. Step 1: Understand parallel test conflicts

   Tests sharing resources can fail when run in parallel. Marking them to run serially avoids conflicts.

2. Step 2: Use pytest markers to control parallelism

   Using @pytest.mark.serial or similar markers tells pytest-xdist to run those tests one by one, while others run in parallel.

3. Step 3: Evaluate other options

   Running all sequentially loses speed benefits, increasing CPU cores doesn't fix resource conflicts, and disabling plugin removes parallelism.

4. Final Answer:

   Mark conflicting tests with @pytest.mark.serial and run others in parallel -> Option A

5. Quick Check:

   Use markers to isolate conflicting tests [OK]

Hint: Mark tests to run serially to fix conflicts [OK]

Common Mistakes:

• Running all tests sequentially losing speed
• Thinking more CPU cores fix resource conflicts
• Disabling plugin instead of isolating tests