Why parametrize multiplies test coverage in PyTest - Test Execution Impact

Test Overview

This test uses pytest's parametrize feature to run the same test logic with different inputs. It verifies that the function correctly identifies even numbers for multiple cases, increasing test coverage efficiently.

Test Code - pytest

PyTest

import pytest

def is_even(num):
    return num % 2 == 0

@pytest.mark.parametrize("input_num,expected", [
    (2, True),
    (3, False),
    (0, True),
    (-4, True),
    (7, False)
])
def test_is_even(input_num, expected):
    assert is_even(input_num) == expected

Execution Trace - 5 Steps

Step	Action	System State	Assertion	Result
1	Test starts with input_num=2 and expected=True	Test environment ready, function is_even loaded	Check if is_even(2) == True	PASS
2	Test runs with input_num=3 and expected=False	Same test function reused with new parameters	Check if is_even(3) == False	PASS
3	Test runs with input_num=0 and expected=True	Test function called again with zero input	Check if is_even(0) == True	PASS
4	Test runs with input_num=-4 and expected=True	Negative even number tested	Check if is_even(-4) == True	PASS
5	Test runs with input_num=7 and expected=False	Odd number tested last	Check if is_even(7) == False	PASS

Failure Scenario

Failing Condition: If is_even returns wrong result for any input

Execution Trace Quiz - 3 Questions

What does pytest parametrize do in this test?

A Skips tests that fail

B Runs different test functions automatically

C Runs the same test multiple times with different inputs

D Runs tests only once

Key Result

Using parametrize in pytest lets you run one test with many inputs, multiplying coverage without writing many test functions.

Practice

1. What is the main benefit of using @pytest.mark.parametrize in tests?

easy

A. It reduces the number of test files needed.

B. It makes tests run faster by skipping some cases.

C. It automatically fixes bugs in the code.

D. It runs the same test multiple times with different inputs to increase coverage.

Solution

1. Step 1: Understand parametrize purpose

   The @pytest.mark.parametrize decorator runs one test function multiple times with different input values.

2. Step 2: Effect on test coverage

   Running tests with varied inputs increases coverage by checking more cases without writing extra test functions.

3. Final Answer:

   It runs the same test multiple times with different inputs to increase coverage. -> Option D

4. Quick Check:

   Parametrize = multiple inputs, more coverage [OK]

Hint: Parametrize repeats tests with different data for more coverage [OK]

Common Mistakes:

• Thinking parametrize skips tests
• Believing it fixes bugs automatically
• Confusing it with reducing test files

2. Which of the following is the correct syntax to parametrize a test with two inputs a and b in pytest?

easy

A. @pytest.mark.parametrize(a, b, [(1, 2), (3, 4)])

B. @pytest.mark.parametrize('a,b', [(1, 2), (3, 4)])

C. @pytest.mark.param('a,b', (1, 2), (3, 4))

D. @pytest.parametrize('a,b', [1, 2, 3, 4])

Solution

1. Step 1: Recall correct decorator name and parameters

   The correct decorator is @pytest.mark.parametrize with a string of parameter names and a list of tuples for values.

2. Step 2: Match syntax to options

   @pytest.mark.parametrize('a,b', [(1, 2), (3, 4)]) correctly uses @pytest.mark.parametrize('a,b', [(1, 2), (3, 4)]). Others have wrong names or formats.

3. Final Answer:

   @pytest.mark.parametrize('a,b', [(1, 2), (3, 4)]) -> Option B

4. Quick Check:

   Correct decorator and tuple list = @pytest.mark.parametrize('a,b', [(1, 2), (3, 4)]) [OK]

Hint: Use @pytest.mark.parametrize with string and list of tuples [OK]

Common Mistakes:

• Misspelling 'parametrize' as 'parametrize' or 'param'
• Passing parameters as separate arguments instead of a string
• Using list instead of list of tuples for multiple inputs

3. Given the following test code, how many times will the test run and what will be the output?

import pytest

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

medium

A. 6 runs; some fail because 0+10 is not > 10

B. 3 runs; all pass because only x is parametrize

C. 6 runs; all pass because sums are always > 10

D. 2 runs; all fail because y is less than 10

Solution

1. Step 1: Calculate total test runs

   Two parametrize decorators multiply: 3 values for x times 2 values for y = 6 runs total.

2. Step 2: Check assertion for each pair

   Pairs: (0,10), (0,20), (1,10), (1,20), (2,10), (2,20). Sum > 10 fails for 0+10=10 (not > 10), passes others.

3. Final Answer:

   6 runs; some fail because 0+10 is not > 10 -> Option A

4. Quick Check:

   Parametrize multiplies runs; check sums > 10 [OK]

Hint: Multiply parametrize counts; check each input pair assertion [OK]

Common Mistakes:

• Assuming runs equal to one parametrize only
• Ignoring assertion failure on boundary values
• Confusing > 10 with >= 10

4. Identify the error in this pytest parametrize usage:

@pytest.mark.parametrize('num', [1, 2, 3])
def test_is_even(num):
    assert num % 2 == 0

medium

A. The test will fail for odd numbers, but syntax is correct.

B. The parametrize decorator is missing parentheses.

C. The parameter name should be a list, not a string.

D. The assert statement syntax is invalid.

Solution

1. Step 1: Check syntax of parametrize

   The decorator syntax is correct: string parameter name and list of values.

2. Step 2: Analyze test logic

   The test asserts number is even. Since 1 and 3 are odd, test will fail for those inputs, but no syntax error.

3. Final Answer:

   The test will fail for odd numbers, but syntax is correct. -> Option A

4. Quick Check:

   Parametrize syntax correct; test logic causes failures [OK]

Hint: Syntax is fine; test logic causes failures on odd numbers [OK]

Common Mistakes:

• Thinking parametrize syntax is wrong
• Confusing parameter name type
• Misreading assert statement as syntax error

5. How does using multiple @pytest.mark.parametrize decorators on a single test function affect test coverage and execution?

hard

A. It causes syntax errors because multiple parametrize decorators are not allowed.

B. It runs tests only for matching pairs of parameters, reducing coverage.

C. It creates a Cartesian product of all parameter values, increasing coverage exponentially.

D. It runs tests sequentially for each decorator, but coverage stays the same.

Solution

1. Step 1: Understand multiple parametrize decorators

   Each decorator adds a set of parameter values. When stacked, pytest runs tests for every combination (Cartesian product) of these values.

2. Step 2: Effect on coverage and execution

   This multiplies test cases, increasing coverage exponentially and testing more input combinations.

3. Final Answer:

   It creates a Cartesian product of all parameter values, increasing coverage exponentially. -> Option C

4. Quick Check:

   Multiple parametrize = Cartesian product = more coverage [OK]

Hint: Stacked parametrize multiplies inputs as Cartesian product [OK]

Common Mistakes:

• Believing multiple decorators reduce coverage
• Thinking multiple decorators cause syntax errors
• Assuming tests run separately without combining inputs