Why parametrize multiplies test coverage in PyTest

Introduction

Parametrizing tests lets you run the same test with many inputs. This helps find more problems quickly without writing many tests.

You want to check a function with different input values.

You need to test multiple user roles with the same test steps.

You want to verify a feature works on various browsers or devices.

You want to test edge cases and normal cases together easily.

You want to avoid repeating similar test code for different data.

Syntax

PyTest

@pytest.mark.parametrize("input,expected", [(value1, result1), (value2, result2), ...])
def test_function(input, expected):
    assert function_to_test(input) == expected

Use a list of tuples to provide multiple sets of inputs and expected results.

The test runs once for each tuple, increasing coverage without extra code.

Examples

This test checks if adding 1 to numbers 1, 3, and 5 gives 2, 4, and 6 respectively.

PyTest

@pytest.mark.parametrize("num,expected", [(1, 2), (3, 4), (5, 6)])
def test_increment(num, expected):
    assert num + 1 == expected

This test verifies string lengths for different inputs.

PyTest

@pytest.mark.parametrize("text,expected_len", [("hello", 5), ("", 0), ("pytest", 6)])
def test_length(text, expected_len):
    assert len(text) == expected_len

Sample Program

This test runs four times with different pairs of numbers to check if their sum matches the expected value.

PyTest

import pytest

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300)
])
def test_addition(a, b, expected):
    assert a + b == expected

Important Notes

Parametrization helps catch bugs that only appear with certain inputs.

It keeps tests clean and avoids repeating similar code.

Use descriptive names for parameters to make tests easy to read.

Summary

Parametrizing runs one test many times with different data.

This increases test coverage without extra test functions.

It helps find more bugs and keeps tests simple.

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