Why parametrize multiplies test coverage in PyTest - Quick Recap

Recall & Review

beginner

What does @pytest.mark.parametrize do in a test?

It runs the same test function multiple times with different input values, increasing test coverage by checking more cases.

beginner

How does parametrize help find bugs?

By testing many input combinations automatically, it can reveal bugs that only happen with certain inputs.

beginner

Why is parametrize better than writing many similar tests?

It saves time and code by reusing one test function with different data instead of writing many separate tests.

beginner

What is a real-life example of parametrize?

Testing a calculator's add function with many pairs of numbers to check all results without writing many tests.

intermediate

How does parametrize improve test reports?

Each input set runs as a separate test case, so reports show exactly which inputs passed or failed.

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

A Skips tests automatically

B Runs tests in parallel

C Generates random test data

D Runs one test multiple times with different inputs

Parametrize runs the same test function multiple times with different input values.

How does parametrize affect test coverage?

A Increases coverage by testing many inputs

B Decreases coverage by limiting inputs

C Has no effect on coverage

D Only tests one input

Parametrize increases coverage by running tests with many different inputs.

Which is NOT a benefit of parametrize?

A Reduces duplicate code

B Improves test clarity by separating cases

C Automatically fixes bugs

D Makes test reports clearer

Parametrize helps find bugs but does not fix them automatically.

What happens if one input case fails in a parametrize test?

A All tests stop immediately

B Only that input case fails, others run normally

C All input cases pass automatically

D Test runner crashes

Each input case runs independently; failure in one does not stop others.

Which syntax correctly uses parametrize?

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

B @pytest.skip def test_add(): pass

C def test_add(): assert 1 + 1 == 2

D @pytest.mark.randomize def test_add(): pass

Option A shows correct parametrize usage with input pairs.

Explain how @pytest.mark.parametrize helps increase test coverage.

Think about running one test many times with different data.

Describe the advantages of using parametrize instead of writing many similar test functions.

Consider code reuse and test clarity.

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