Testing in Python becomes more robust and elegant with the use of pytest, a powerful testing framework. One of its standout features is the ability to pass parameters dynamically to fixtures, enhancing the flexibility of your tests. In this post, we’ll dive into how to achieve this.

What is a Fixture in Pytest?

Before we jump into dynamic parameterization, let’s understand what a fixture is. In pytest, a fixture is a function you write that sets up a certain state or environment needed for testing. Fixtures are reusable and can be applied to multiple test functions, promoting clean and efficient test code.

Dynamic Parameterization: The Basics

Dynamic parameterization in pytest refers to the ability to pass different parameters to a fixture each time it’s used. This feature is incredibly useful when you want to test the same logic under different conditions.

Step 1: Defining a Fixture with Request Parameter

First, define your fixture to accept a request parameter. This request is a built-in pytest fixture that allows you to access the parameters passed to the fixture.

import pytest

def my_fixture(request):
    param = request.param
    klass_instance = Klass()
    klass_instance.some_attr = param

    # Another logic using param

    return klass_instance

Step 2: Using Parametrize with Indirect=True

Next, use the pytest.mark.parametrize decorator in your test functions. The key is to set indirect=True. This tells pytest that the parameters should be passed to the fixture, not to the test function directly.

@pytest.mark.parametrize("my_fixture", [param1, param2], indirect=True)
def test_my_function(my_fixture):
    # Your test code here

How It Works

When pytest runs test_my_function, it invokes my_fixture twice: once with param1 and once with param2. This approach is perfect for testing different scenarios using the same test logic.

Practical Example

Let’s say you’re testing a database connection function with different connection strings. You can create a fixture that takes a connection string as a parameter and establishes a database connection. Using pytest.mark.parametrize, you can pass different connection strings to test various scenarios like valid connections, invalid credentials, or unreachable databases.


Dynamic parameterization in pytest is a powerful feature that adds versatility to your tests. By following the steps outlined above, you can leverage this feature to create more effective and comprehensive test suites.

Remember, clean and efficient testing leads to robust and reliable code, and pytest’s fixtures are a great tool in achieving this goal.

All done!