Why parametrize multiplies test coverage in PyTest - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does pytest parametrize increase test coverage?

Consider a test function that uses @pytest.mark.parametrize to run multiple input values. Why does this approach multiply test coverage?

A It skips tests that are redundant, reducing coverage but saving time.

B It runs tests in parallel, speeding up execution but not increasing coverage.

C It automatically generates new test functions from the code under test.

D It runs the same test logic multiple times with different inputs, covering more cases.

💡 Hint

Think about how running a test with different inputs affects the number of scenarios checked.

Parametrization runs the same test logic multiple times with different inputs. This means more scenarios are tested, increasing coverage.

❓ Predict Output

intermediate

Output of parametrized pytest test count

Given the following pytest test code, how many tests will be executed?

PyTest

import pytest

@pytest.mark.parametrize('x', [1, 2])
@pytest.mark.parametrize('y', [3, 4, 5])
def test_sum(x, y):
    assert x + y > 0

A 6

B 5

C 3

D 2

💡 Hint

Multiply the number of values in each parametrize decorator.

There are 2 values for x and 3 for y. The total tests run is 2 * 3 = 6.

❓ assertion

advanced

Correct assertion for parametrized test coverage

Which assertion correctly verifies that a parametrized test ran all expected cases?

PyTest

import pytest

@pytest.mark.parametrize('val', [10, 20, 30])
def test_positive(val):
    assert val > 0

A assert pytest.main(['-v']).count('test_positive') == 3

B assert pytest.main(['-v']).count('test_positive') == 0

C assert pytest.main(['-v']).count('test_positive') == 1

D assert pytest.main(['-v']).count('test_positive') == 6

💡 Hint

Count how many times the test function name appears in verbose output.

Since the test is parametrized with 3 values, it runs 3 times. The count should be 3.

🔧 Debug

advanced

Identify the error in parametrized test coverage

Why does this parametrized test not increase coverage as expected?

PyTest

import pytest

@pytest.mark.parametrize('a', [1, 2])
def test_example(a):
    assert a != 0

@pytest.mark.parametrize('b', [3, 4])
def test_example(b):
    assert b != 0

A Both tests run with 4 total cases, coverage is correct.

B The second test_example overwrites the first, so only 2 tests run.

C Parametrize decorators must be combined on one function to multiply coverage.

D The test names must be different to run both parametrized tests.

💡 Hint

Check if function names are unique in the test file.

Both functions have the same name, so the second overwrites the first. Only 2 tests run, not 4.

❓ framework

expert

How does pytest parametrize multiply coverage internally?

Which mechanism does pytest use internally to multiply test coverage when using @pytest.mark.parametrize?

A It runs the test once and caches results for all inputs.

B It modifies the test function code to loop over inputs during execution.

C It generates multiple test function calls with different arguments at collection time.

D It duplicates the test file for each parameter set before running tests.

💡 Hint

Think about when pytest creates separate test cases for each parameter.

Pytest creates multiple test calls with different arguments during test collection, so each runs independently.