Bird
Raised Fist0
PyTesttesting~15 mins

Parametrized fixtures in PyTest - Build an Automation Script

Choose your learning style10 modes available
Test login with multiple user credentials using parametrized fixture
Preconditions (2)
Step 1: Open the login page.
Step 2: Enter the username from the test data into the username field.
Step 3: Enter the password from the test data into the password field.
Step 4: Click the login button.
Step 5: Verify that the user is redirected to the dashboard page with URL containing '/dashboard'.
Step 6: Logout to prepare for the next test data input.
✅ Expected Result: For each set of credentials, the user successfully logs in and is redirected to the dashboard page.
Automation Requirements - pytest
Assertions Needed:
Verify the current URL contains '/dashboard' after login.
Verify the login button is clickable before clicking.
Verify logout button is present after login.
Best Practices:
Use pytest parametrized fixtures to supply multiple sets of credentials.
Use explicit waits to ensure elements are interactable.
Keep test functions simple and readable.
Use fixture scope appropriately.
Automated Solution
PyTest
import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

@pytest.fixture(params=[
    {"username": "user1@example.com", "password": "Pass123!"},
    {"username": "user2@example.com", "password": "Pass456!"},
    {"username": "user3@example.com", "password": "Pass789!"}
])
def credentials(request):
    return request.param

@pytest.fixture
def driver():
    driver = webdriver.Chrome()
    driver.implicitly_wait(5)
    yield driver
    driver.quit()

def test_login_with_parametrized_credentials(driver, credentials):
    driver.get("http://example.com/login")

    # Wait for username field and enter username
    username_field = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.ID, "username"))
    )
    username_field.clear()
    username_field.send_keys(credentials["username"])

    # Wait for password field and enter password
    password_field = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.ID, "password"))
    )
    password_field.clear()
    password_field.send_keys(credentials["password"])

    # Wait for login button and click
    login_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.ID, "loginBtn"))
    )
    login_button.click()

    # Verify URL contains '/dashboard'
    WebDriverWait(driver, 10).until(
        EC.url_contains("/dashboard")
    )
    assert "/dashboard" in driver.current_url

    # Verify logout button is present
    logout_button = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "logoutBtn"))
    )
    assert logout_button.is_displayed()

    # Logout to reset state
    logout_button.click()

This test uses a pytest parametrized fixture named credentials to supply three different sets of user login data.

The driver fixture sets up the Selenium WebDriver and ensures it quits after the test.

The test function test_login_with_parametrized_credentials uses these fixtures. It opens the login page, waits explicitly for each element to be clickable before interacting, and enters the username and password from the current parameter set.

After clicking login, it waits until the URL contains '/dashboard' to confirm successful login, then asserts this condition.

It also checks that the logout button is visible, confirming the user is logged in.

Finally, it clicks logout to reset the state for the next test iteration.

This approach keeps tests clean, readable, and reliable by using explicit waits and parametrization.

Common Mistakes - 3 Pitfalls
Hardcoding credentials inside the test function instead of using parametrized fixtures
Not using explicit waits before interacting with elements
Not resetting the application state after each test iteration
Bonus Challenge

Now add data-driven testing with 3 different sets of invalid credentials and verify login failure message.

Show Hint

Practice

(1/5)
1. What is the main purpose of using @pytest.fixture(params=[...]) in pytest?
easy
A. To run the same test multiple times with different input data
B. To skip a test conditionally
C. To mark a test as expected to fail
D. To group multiple tests into a single test case

Solution

  1. Step 1: Understand the role of parametrized fixtures

    Parametrized fixtures allow running a test function multiple times with different data inputs automatically.
  2. Step 2: Match the purpose with the options

    To run the same test multiple times with different input data correctly describes this behavior, while others describe unrelated pytest features.
  3. Final Answer:

    To run the same test multiple times with different input data -> Option A
  4. Quick Check:

    Parametrized fixtures = run test multiple times [OK]
Hint: Parametrized fixtures repeat tests with different data [OK]
Common Mistakes:
  • Confusing parametrized fixtures with test skipping
  • Thinking it groups tests instead of repeating them
  • Mixing up with expected failure markers
2. Which of the following is the correct syntax to define a parametrized fixture in pytest?
easy
A. @pytest.fixture(param=[1, 2, 3])\ndef data(request):\n return request.param
B. @pytest.param(params=[1, 2, 3])\ndef data(request):\n return request.param
C. @pytest.fixture(params=[1, 2, 3])\ndef data(request):\n return request.param
D. @pytest.fixture(params=(1, 2, 3))\ndef data():\n return param

Solution

  1. Step 1: Identify correct decorator and parameter name

    The correct decorator is @pytest.fixture with the keyword params as a list.
  2. Step 2: Check function signature and usage

    The fixture function must accept request and return request.param to access each parameter value.
  3. Final Answer:

    @pytest.fixture(params=[1, 2, 3])\ndef data(request):\n return request.param -> Option C
  4. Quick Check:

    Use @pytest.fixture(params=[...]) and request.param [OK]
Hint: Use @pytest.fixture(params=[...]) and request.param inside function [OK]
Common Mistakes:
  • Using @pytest.param instead of @pytest.fixture
  • Misspelling 'params' as 'param'
  • Not including 'request' parameter in fixture function
  • Returning undefined variable instead of request.param
3. Given the following pytest code, what will be the output when running the test?
import pytest

@pytest.fixture(params=[10, 20])
def number(request):
    return request.param

def test_double(number):
    assert number * 2 in [20, 40]
medium
A. First test fails, second test passes
B. Both tests fail
C. First test passes, second test fails
D. Both tests pass

Solution

  1. Step 1: Understand parametrized fixture values

    The fixture 'number' will run the test twice: once with 10, once with 20.
  2. Step 2: Evaluate the assertion for each value

    For 10: 10*2=20, which is in [20,40]. For 20: 20*2=40, also in [20,40]. Both assertions pass.
  3. Final Answer:

    Both tests pass -> Option D
  4. Quick Check:

    10*2=20 and 20*2=40 both in list [OK]
Hint: Check each param value and test assertion separately [OK]
Common Mistakes:
  • Assuming only one test runs
  • Misreading the assertion condition
  • Forgetting fixture runs test multiple times
4. Identify the error in this parametrized fixture code snippet:
@pytest.fixture(params=["a", "b"])
def letter():
    return param

def test_letter(letter):
    assert letter in ["a", "b"]
medium
A. Wrong assertion in test function
B. Missing 'request' parameter in fixture function
C. Incorrect decorator name
D. Fixture should not return any value

Solution

  1. Step 1: Check fixture function parameters

    The fixture uses params, so it must accept request to access request.param.
  2. Step 2: Identify incorrect return statement

    The function returns param, which is undefined. It should return request.param.
  3. Final Answer:

    Missing 'request' parameter in fixture function -> Option B
  4. Quick Check:

    Parametrized fixture needs 'request' param [OK]
Hint: Parametrized fixtures must accept 'request' to use request.param [OK]
Common Mistakes:
  • Not including 'request' parameter in fixture
  • Returning undefined variable instead of request.param
  • Confusing fixture decorator names
5. You want to test a function with multiple sets of user data, but some data sets are invalid and should be skipped. How can you modify a parametrized fixture to skip tests for invalid data?
hard
A. Use pytest.skip() inside the fixture when data is invalid
B. Remove invalid data from the params list before parametrizing
C. Raise an exception inside the test function for invalid data
D. Use pytest.mark.skipif on the test function with a condition

Solution

  1. Step 1: Understand skipping inside parametrized fixtures

    Inside the fixture, you can call pytest.skip() when the current parameter is invalid to skip that test run.
  2. Step 2: Compare with other options

    Removing invalid data beforehand avoids testing them but doesn't show skipped tests. Raising exceptions fails tests, not skip. Using skipif on test function is less flexible for per-parameter skipping.
  3. Final Answer:

    Use pytest.skip() inside the fixture when data is invalid -> Option A
  4. Quick Check:

    Call pytest.skip() in fixture to skip invalid params [OK]
Hint: Call pytest.skip() inside fixture for invalid params [OK]
Common Mistakes:
  • Removing invalid data silently instead of skipping
  • Raising exceptions instead of skipping
  • Using skipif without parameter-specific logic
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard