Conditional parametrize in PyTest - Deep Dive

Overview - Conditional parametrize

What is it?

Conditional parametrize is a way to run the same test multiple times with different inputs, but only include some inputs based on certain conditions. It helps you test many cases without writing separate tests for each. This makes tests easier to manage and more flexible.

Why it matters

Without conditional parametrize, you might run tests with irrelevant or invalid inputs, wasting time and causing confusion. It solves the problem of testing only what matters in different situations, like different environments or versions. This saves time and makes test results clearer and more reliable.

Where it fits

Before learning conditional parametrize, you should understand basic pytest tests and simple parametrize usage. After this, you can learn advanced test selection, fixtures, and test optimization techniques.

Mental Model

Core Idea

Conditional parametrize lets you choose which test inputs to run based on rules, so tests stay relevant and efficient.

Think of it like...

It's like packing a suitcase for a trip but only including clothes for the weather you expect, not everything you own.

Test Function
  │
  ├─ Parametrize Inputs ──> [Input1, Input2, Input3, ...]
  │                         │
  │                         └─ Condition Filter ──> [Input1, Input3]
  │
  └─ Run Test with Filtered Inputs

Build-Up - 6 Steps

1

Foundation

Basic pytest parametrize usage

Concept: Learn how to run a test multiple times with different inputs using pytest parametrize.

In pytest, you can use @pytest.mark.parametrize to run a test function with different values. For example: import pytest @pytest.mark.parametrize('x', [1, 2, 3]) def test_example(x): assert x > 0 This runs test_example three times with x=1, x=2, and x=3.

Result

The test runs three times, each with a different value of x, and all pass because all are greater than zero.

Understanding basic parametrize is essential because conditional parametrize builds on this to selectively run tests.

2

Foundation

Why parametrize tests matter

Concept: Understand the benefit of running tests with multiple inputs automatically.

Instead of writing separate tests for each input, parametrize lets you write one test that covers many cases. This reduces code duplication and makes tests easier to maintain. Example: @pytest.mark.parametrize('input,expected', [(1,2), (3,4)]) def test_add_one(input, expected): assert input + 1 == expected

Result

Two tests run, checking if adding one to input matches expected values.

Knowing this saves time and effort, making tests more scalable and less error-prone.

3

Intermediate

Adding conditions to parametrize inputs

🤔Before reading on: do you think you can use Python code inside parametrize to skip some inputs? Commit to yes or no.

Concept: Learn how to filter or select inputs dynamically before running tests.

You can create a list of inputs and then filter it with Python code before passing it to parametrize. Example: inputs = [1, 2, 3, 4] filtered = [x for x in inputs if x % 2 == 0] @pytest.mark.parametrize('x', filtered) def test_even(x): assert x % 2 == 0 This runs the test only for even numbers.

Result

The test runs twice, with x=2 and x=4, both passing the even check.

Using Python logic to filter inputs before parametrize lets you control test scope flexibly.

4

Intermediate

Using pytest hooks for conditional parametrize

🤔Before reading on: do you think pytest can modify test parameters at runtime using hooks? Commit to yes or no.

Concept: Learn how pytest hooks can dynamically change test parameters based on environment or other factors.

Pytest provides hooks like pytest_generate_tests that let you customize parameters dynamically. Example: def pytest_generate_tests(metafunc): if 'x' in metafunc.fixturenames: values = [1, 2, 3] if some_condition(): values = [v for v in values if v != 2] metafunc.parametrize('x', values) This runs tests with x values filtered by some_condition.

Result

Tests run with parameters adjusted at runtime, skipping some inputs if conditions apply.

Hooks provide powerful control to adapt tests to different contexts without changing test code.

5

Advanced

Combining parametrize with skipif markers

🤔Before reading on: can you skip individual parametrize cases conditionally using pytest markers? Commit to yes or no.

Concept: Learn how to mark specific parameter sets to skip based on conditions.

You can use pytest.param with marks to skip certain inputs. Example: import sys import pytest @pytest.mark.parametrize('x', [ 1, pytest.param(2, marks=pytest.mark.skipif(sys.platform == 'win32', reason='Skip on Windows')), 3 ]) def test_example(x): assert x > 0 This skips the test case with x=2 on Windows.

Result

On Windows, the test runs twice (x=1 and x=3). On other OSes, it runs three times.

Marking individual parameters for skip lets you fine-tune test runs without complex filtering.

6

Expert

Dynamic conditional parametrize with custom decorators

🤔Before reading on: do you think you can create your own decorator to conditionally parametrize tests? Commit to yes or no.

Concept: Learn how to build reusable decorators that apply conditional parametrize logic automatically.

You can write a custom decorator that wraps pytest.mark.parametrize and applies conditions internally. Example: import pytest def conditional_parametrize(argnames, argvalues, condition): filtered = [v for v in argvalues if condition(v)] return pytest.mark.parametrize(argnames, filtered) @conditional_parametrize('x', [1, 2, 3, 4], lambda v: v % 2 == 1) def test_odd(x): assert x % 2 == 1 This runs only for odd numbers, hiding filtering inside the decorator.

Result

The test runs three times with x=1, x=3, and x=4 filtered out.

Custom decorators encapsulate conditional logic, making tests cleaner and reusable across projects.

Under the Hood

Pytest collects test functions and applies decorators like parametrize to generate multiple test cases. Conditional parametrize works by filtering or modifying the list of input parameters before pytest creates individual test instances. Hooks like pytest_generate_tests run during collection to dynamically adjust parameters. Skip markers attach metadata to specific test cases, telling pytest to skip them during execution.

Why designed this way?

Pytest was designed to be flexible and extensible, allowing users to control test generation dynamically. Conditional parametrize leverages Python's dynamic features and pytest's hook system to avoid hardcoding test cases. This design balances simplicity for common cases and power for complex scenarios.

Test Collection Phase
  │
  ├─ Test Functions
  │    └─ Decorators (parametrize)
  │          └─ Input Parameters List
  │                └─ Conditional Filtering (Python code or hooks)
  │                      └─ Filtered Parameters
  └─ Test Instances Created
         └─ Skip Markers Applied
  │
  └─ Test Execution

Myth Busters - 4 Common Misconceptions

Quick: Does parametrize automatically skip invalid inputs without extra code? Commit yes or no.

Common Belief: Parametrize will automatically skip or ignore inputs that don't meet conditions.

Reality: Parametrize runs all inputs given unless you explicitly filter or mark them to skip.

Why it matters: Assuming automatic skipping causes tests to fail unexpectedly or run irrelevant cases, wasting time.

Quick: Can you use skipif markers on the whole test function to skip individual parametrize cases? Commit yes or no.

Common Belief: Applying skipif on the test function skips specific parametrize cases automatically.

Reality: Skipif on the test function skips the entire test, not individual parameter sets; you must mark parameters individually.

Why it matters: Misusing skipif leads to skipping all tests or none, causing confusion and incorrect test coverage.

Quick: Is it better to write separate tests than use conditional parametrize for complex conditions? Commit yes or no.

Common Belief: Writing separate tests is simpler and clearer than using conditional parametrize for complex input selection.

Reality: Conditional parametrize keeps tests DRY and easier to maintain, even with complex conditions, if used properly.

Why it matters: Avoiding conditional parametrize leads to duplicated code and harder test maintenance.

Quick: Does filtering inputs inside parametrize slow down test execution significantly? Commit yes or no.

Common Belief: Filtering inputs inside parametrize causes big performance hits during test runs.

Reality: Filtering happens once during test collection, so runtime performance is not affected.

Why it matters: Misunderstanding this may cause unnecessary avoidance of conditional parametrize, missing its benefits.

Expert Zone

1

Conditional parametrize can interact subtly with fixtures, requiring careful ordering to avoid conflicts.

2

Using pytest hooks for conditional parametrize allows environment-aware tests but can complicate test discovery and debugging.

3

Marking parameters with skipif is more efficient than filtering large input lists, especially when skipping depends on runtime conditions.

When NOT to use

Avoid conditional parametrize when test inputs are simple and static; use plain parametrize instead. For very complex test selection, consider pytest's built-in test selection options or custom test collection plugins.

Production Patterns

In real projects, conditional parametrize is used to run tests only on supported platforms, skip slow tests in quick runs, or test features conditionally based on configuration. Teams often combine it with CI environment variables to control test scope dynamically.

Connections

Feature Flags

Both control behavior based on conditions to enable or disable features or tests.

Understanding conditional parametrize helps grasp how feature flags selectively activate code paths in production.

Database Query Filters

Conditional parametrize filters test inputs like query filters select data subsets.

Knowing how filters work in databases clarifies how test inputs can be dynamically selected for relevance.

Selective Breeding in Biology

Both involve choosing specific traits or inputs based on conditions to achieve desired outcomes.

Seeing conditional parametrize as selective breeding highlights the importance of choosing only useful test cases.

Common Pitfalls

#1 Running tests with all inputs regardless of conditions.

Wrong approach:

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

Correct approach:

inputs = [1, 2, 3, 4]
filtered = [x for x in inputs if x % 2 == 0]

@pytest.mark.parametrize('x', filtered)
def test_filtered(x):
assert x > 0

Root cause:

Not filtering inputs before parametrize causes irrelevant tests to run.

#2 Using skipif on the test function to skip some parametrize cases.

Wrong approach:

@pytest.mark.skipif(sys.platform == 'win32', reason='Skip on Windows')
@pytest.mark.parametrize('x', [1, 2, 3])
def test_func(x):
assert x > 0

Correct approach:

@pytest.mark.parametrize('x', [
1,
pytest.param(2, marks=pytest.mark.skipif(sys.platform == 'win32', reason='Skip on Windows')),
3
])
def test_func(x):
assert x > 0

Root cause:

Misunderstanding skipif scope causes skipping entire test instead of specific cases.

#3 Hardcoding complex conditions inside test functions instead of parametrize.

Wrong approach:

def test_func(x):
if x % 2 != 0:
pytest.skip('Skip odd')
assert x % 2 == 0

Correct approach:

inputs = [1, 2, 3, 4]
filtered = [x for x in inputs if x % 2 == 0]

@pytest.mark.parametrize('x', filtered)
def test_func(x):
assert x % 2 == 0

Root cause:

Placing conditions inside tests leads to skipped tests after running, wasting time.

Key Takeaways

Conditional parametrize lets you run tests only with relevant inputs by filtering or marking parameters.

It improves test efficiency and clarity by avoiding irrelevant or unsupported test cases.

You can implement conditional parametrize using Python filtering, pytest hooks, or skip markers on parameters.

Misusing skip markers or filtering can cause unexpected test runs or skips, so understanding scope is crucial.

Advanced use includes custom decorators and environment-aware test selection for flexible, maintainable test suites.