Parameterize with test data in Selenium Python - Deep Dive

Overview - Parameterize with test data

What is it?

Parameterizing with test data means running the same test multiple times with different inputs. Instead of writing many tests for each input, you write one test that accepts data. This helps check how the software behaves with various values. It makes testing faster and more organized.

Why it matters

Without parameterization, testers write repetitive tests for each input, wasting time and risking mistakes. Parameterization saves effort and finds bugs that only appear with certain data. It helps deliver reliable software that works well for many users and situations.

Where it fits

Before learning parameterization, you should know how to write basic Selenium tests in Python. After mastering it, you can learn advanced test frameworks like pytest fixtures and data-driven testing techniques.

Mental Model

Core Idea

Parameterization runs one test many times with different data to check all cases efficiently.

Think of it like...

It's like cooking one recipe but changing the ingredients each time to see how the taste changes.

┌───────────────┐
│ Test Function │
└──────┬────────┘
       │ runs with
       ▼
┌───────────────┐
│ Test Data Set │
│  input1       │
│  input2       │
│  input3       │
└───────────────┘
       │
       ▼
┌───────────────┐
│ Multiple Runs │
│  Run 1: input1│
│  Run 2: input2│
│  Run 3: input3│
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Basics of Selenium Test Scripts

Concept: Learn how to write a simple Selenium test in Python that opens a webpage and checks something.

from selenium import webdriver from selenium.webdriver.common.by import By # Open browser and go to example.com driver = webdriver.Chrome() driver.get('https://example.com') # Check page title assert 'Example Domain' in driver.title driver.quit()

Result

The browser opens example.com, checks the title, and closes without errors if the title matches.

Understanding how to write a basic Selenium test is essential before adding complexity like parameterization.

2

Foundation

Why Repeat Tests with Different Data?

Concept: Tests often need to check many inputs to find bugs that only appear with certain values.

Imagine a login form that accepts usernames and passwords. Testing only one username might miss errors with others. So, testers try many usernames and passwords to be sure.

Result

You see that testing multiple inputs is necessary to cover all cases and avoid missing bugs.

Knowing why multiple data inputs matter motivates using parameterization to avoid repetitive code.

3

Intermediate

Manual Data Variation in Tests

🤔Before reading on: do you think writing separate tests for each input is efficient or wasteful? Commit to your answer.

Concept: Try running the same test code multiple times with different hardcoded inputs to see the problem.

def test_login_user1(): # test with user1 pass def test_login_user2(): # test with user2 pass # This repeats code and is hard to maintain.

Result

You realize writing many similar tests wastes time and causes duplication.

Seeing the pain of repeated code helps understand why parameterization is a better approach.

4

Intermediate

Using pytest.mark.parametrize Decorator

🤔Before reading on: do you think pytest can run one test with many inputs automatically? Commit to yes or no.

Concept: pytest has a feature called parametrize that runs one test function multiple times with different data.

import pytest @pytest.mark.parametrize('username,password', [ ('user1', 'pass1'), ('user2', 'pass2'), ('user3', 'pass3') ]) def test_login(username, password): print(f'Testing login with {username} and {password}') assert username.startswith('user')

Result

pytest runs test_login three times, each with different username and password values.

Knowing pytest can automate multiple test runs with different data saves time and reduces errors.

5

Intermediate

Parameterizing Selenium Tests with pytest

🤔Before reading on: do you think Selenium tests can use pytest parametrize to test multiple inputs? Commit to yes or no.

Concept: Combine Selenium and pytest parametrize to run browser tests with different data sets automatically.

import pytest from selenium import webdriver @pytest.mark.parametrize('search_term', ['apple', 'banana', 'cherry']) def test_google_search(search_term): driver = webdriver.Chrome() driver.get('https://www.google.com') search_box = driver.find_element('name', 'q') search_box.send_keys(search_term) search_box.submit() assert search_term in driver.title.lower() driver.quit()

Result

The test runs three times, searching Google for each fruit and checking the page title.

Integrating parameterization with Selenium tests makes testing many inputs easy and scalable.

6

Advanced

Using External Data Sources for Parameterization

🤔Before reading on: do you think test data can come from files like CSV or JSON instead of hardcoded lists? Commit to yes or no.

Concept: Test data can be loaded from external files to separate data from test code and handle large datasets.

import pytest import csv # Load test data from CSV file def load_test_data(): with open('test_data.csv') as f: reader = csv.reader(f) return list(reader) @pytest.mark.parametrize('username,password', load_test_data()) def test_login_external(username, password): print(f'Testing login with {username} and {password}') assert username and password

Result

Tests run once for each row in the CSV file, allowing easy updates to test data without changing code.

Separating test data from code improves maintainability and supports large-scale testing.

7

Expert

Handling Complex Data and Fixtures in Parameterization

🤔Before reading on: do you think parameterized tests can use setup code (fixtures) that depend on the test data? Commit to yes or no.

Concept: pytest fixtures can prepare environments or objects that change based on parameterized data, enabling complex test setups.

import pytest @pytest.fixture def setup_env(request): data = request.param print(f'Setting up environment for {data}') return data @pytest.mark.parametrize('setup_env', ['dev', 'staging', 'prod'], indirect=True) def test_environment(setup_env): assert setup_env in ['dev', 'staging', 'prod']

Result

The test runs three times, each with a different environment setup prepared by the fixture.

Combining parameterization with fixtures allows flexible, powerful test scenarios that mirror real-world complexity.

Under the Hood

pytest's parametrize decorator creates multiple test instances by injecting different data into the test function's parameters. Internally, pytest generates separate test cases for each data set, runs them independently, and reports results separately. Selenium WebDriver commands execute in each test instance, controlling the browser with the given inputs.

Why designed this way?

This design separates test logic from data, reducing duplication and improving clarity. It allows easy scaling of tests without rewriting code. Alternatives like writing many separate tests were error-prone and hard to maintain. pytest's approach balances simplicity and power.

┌───────────────┐
│ Test Function │
│ with params   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ pytest engine │
│ expands data  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Test Instance │
│ 1 with data1  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Selenium run  │
│ with data1    │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does parameterizing tests mean writing one test that runs only once? Commit to yes or no.

Common Belief: Parameterizing means writing one test that runs a single time with some data.

Reality: Parameterizing means the test runs multiple times, once for each data set provided.

Why it matters: Thinking it runs once causes testers to miss bugs that appear only with other inputs.

Quick: Do you think parameterized tests share browser sessions across runs? Commit to yes or no.

Common Belief: All parameterized test runs share the same browser session to save time.

Reality: Each parameterized test run should start a fresh browser session to avoid state interference.

Why it matters: Sharing sessions can cause flaky tests and false failures due to leftover data.

Quick: Is it true that parameterizing tests always makes them slower? Commit to yes or no.

Common Belief: Parameterizing tests always slows down the test suite because it runs more tests.

Reality: While more tests run, parameterization avoids duplicated code and can be optimized with parallel runs.

Why it matters: Believing tests must be slow may discourage testers from using parameterization, missing its benefits.

Quick: Can you parameterize tests with complex objects like fixtures easily? Commit to yes or no.

Common Belief: Parameterization only works with simple data like strings or numbers.

Reality: pytest supports parameterizing with complex objects and fixtures for advanced scenarios.

Why it matters: Underestimating this limits test design and misses powerful testing patterns.

Expert Zone

1

Parameterized tests can be combined with pytest fixtures using 'indirect' parameterization to customize setup per data set.

2

Test IDs can be customized in pytest parametrize to produce readable test names in reports, aiding debugging.

3

Parameterization order and scope affect test isolation and performance; understanding pytest's collection order helps optimize runs.

When NOT to use

Avoid parameterization when tests require completely different setups or logic per case; use separate test functions instead. For very large data sets, consider sampling or filtering to keep test time reasonable.

Production Patterns

In real projects, parameterization is used for cross-browser testing, input validation with many edge cases, and integration tests with multiple configurations. Teams combine it with CI pipelines to run tests in parallel, speeding feedback.

Connections

Data-Driven Testing

Parameterization is a core technique to implement data-driven testing.

Understanding parameterization clarifies how data-driven testing automates checking many inputs efficiently.

Continuous Integration (CI)

Parameterization enables CI systems to run comprehensive tests quickly and reliably.

Knowing parameterization helps optimize CI pipelines by reducing redundant tests and improving coverage.

Mathematical Function Mapping

Parameterization maps one test function over many input values, like applying a function to multiple arguments.

Seeing tests as functions applied to data deepens understanding of test automation logic.

Common Pitfalls

#1 Reusing the same browser instance across parameterized tests causing state leakage.

Wrong approach:

driver = webdriver.Chrome()

@pytest.mark.parametrize('input', ['a', 'b'])
def test_example(input):
driver.get('https://example.com')
# test steps

# driver.quit() called only once after all tests

Correct approach:

@pytest.mark.parametrize('input', ['a', 'b'])
def test_example(input):
driver = webdriver.Chrome()
driver.get('https://example.com')
# test steps
driver.quit()

Root cause:

Misunderstanding that each test run needs a fresh browser to avoid leftover data affecting results.

#2 Hardcoding test data inside test functions making updates difficult.

Wrong approach:

@pytest.mark.parametrize('user', ['user1', 'user2'])
def test_login(user):
# test code
pass

Correct approach:

def load_users():
return ['user1', 'user2']

@pytest.mark.parametrize('user', load_users())
def test_login(user):
# test code
pass

Root cause:

Not separating data from code reduces flexibility and maintainability.

#3 Using parameter names that do not match test function arguments causing errors.

Wrong approach:

@pytest.mark.parametrize('username,password', [('u1','p1')])
def test_login(user, passw):
pass

Correct approach:

@pytest.mark.parametrize('username,password', [('u1','p1')])
def test_login(username, password):
pass

Root cause:

Mismatch between parameter names and function arguments leads to runtime failures.

Key Takeaways

Parameterization runs one test multiple times with different data, saving time and improving coverage.

pytest's parametrize decorator is a powerful tool to automate data-driven testing in Python.

Separating test data from test code improves maintainability and supports large test suites.

Each parameterized test run should be isolated to avoid interference and flaky tests.

Advanced parameterization can combine with fixtures for flexible, real-world test scenarios.

Practice

1. What is the main purpose of using @pytest.mark.parametrize in Selenium Python tests?

easy

A. To run tests in parallel threads

B. To skip tests that are not ready

C. To run the same test function multiple times with different input data

D. To generate HTML reports automatically

Solution

1. Step 1: Understand the decorator's role

   @pytest.mark.parametrize allows running one test function multiple times with different sets of input data.

2. Step 2: Compare with other options

   Skipping tests, running in parallel, or generating reports are different pytest features, not related to parameterization.

3. Final Answer:

   To run the same test function multiple times with different input data -> Option C

4. Quick Check:

   Parameterize = run test with many inputs [OK]

Hint: Parameterize means run test repeatedly with different data [OK]

Common Mistakes:

• Confusing parameterize with skipping tests
• Thinking it runs tests in parallel
• Assuming it generates reports

2. Which of the following is the correct syntax to parameterize a test function with two sets of inputs ("user1", "pass1") and ("user2", "pass2") in pytest?

easy

A. @pytest.parametrize('username', ['user1', 'user2'], 'password', ['pass1', 'pass2'])

B. @pytest.mark.parametrize('username, password', [('user1', 'pass1'), ('user2', 'pass2')])

C. @pytest.mark.parametrize(['username', 'password'], 'user1', 'pass1', 'user2', 'pass2')

D. @pytest.mark.parametrized('username', 'password', [('user1', 'pass1'), ('user2', 'pass2')])

Solution

1. Step 1: Recall correct decorator syntax

   The correct syntax uses @pytest.mark.parametrize with a string of parameter names and a list of tuples for values.

2. Step 2: Identify correct option

   @pytest.mark.parametrize('username, password', [('user1', 'pass1'), ('user2', 'pass2')]) matches the correct syntax exactly. Other options have wrong method names or argument formats.

3. Final Answer:

   @pytest.mark.parametrize('username, password', [('user1', 'pass1'), ('user2', 'pass2')]) -> Option B

4. Quick Check:

   Parametrize('params', [tuples]) = correct syntax [OK]

Hint: Use string param names and list of tuples for values [OK]

Common Mistakes:

• Misspelling 'parametrize' as 'parametrized' or 'parametrize'
• Passing parameters as separate lists instead of tuples
• Using wrong decorator name

3. Given the following test code, what will be the output when running the test?

import pytest

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

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: Analyze each test case

   For (1, 2): 1 + 1 = 2, assertion passes. For (3, 4): 3 + 1 = 4, assertion passes.

2. Step 2: Determine overall result

   Since both assertions pass, both tests pass successfully.

3. Final Answer:

   Both tests pass -> Option D

4. Quick Check:

   num+1 == expected for all inputs [OK]

Hint: Check each input pair separately for assertion [OK]

Common Mistakes:

• Assuming one test fails without checking values
• Confusing expected values with actual calculation
• Ignoring that both inputs are tested

4. Identify the error in the following parameterized test code:

import pytest

@pytest.mark.parametrize('username, password')
def test_login(username, password):
    assert username != '' and password != ''

medium

A. Missing list of parameter values in @pytest.mark.parametrize decorator

B. Function parameters do not match decorator parameters

C. Assertion logic is incorrect

D. pytest module is not imported

Solution

1. Step 1: Check decorator usage

   The decorator @pytest.mark.parametrize requires two arguments: parameter names and a list of values. Here, the list of values is missing.

2. Step 2: Verify other parts

   Function parameters match decorator names, assertion logic is valid, and pytest is imported correctly.

3. Final Answer:

   Missing list of parameter values in @pytest.mark.parametrize decorator -> Option A

4. Quick Check:

   Parametrize needs names and values [OK]

Hint: Always provide parameter values list with parametrize [OK]

Common Mistakes:

• Forgetting the list of test data tuples
• Mismatching parameter names and function arguments
• Incorrect assertion logic

5. You want to test a login form with multiple username and password pairs using Selenium and pytest. Which approach correctly applies parameterization and Selenium WebDriver usage together?

hard

A. Use @pytest.mark.parametrize to pass username and password, then inside the test open the browser, enter credentials, and assert login success

B. Write separate test functions for each username and password pair without parameterization

C. Use a loop inside a single test function to iterate over username and password pairs without parameterization

D. Use @pytest.mark.parametrize but open the browser only once outside the test function

Solution

1. Step 1: Understand parameterization with Selenium

   Parameterization with @pytest.mark.parametrize allows running the test multiple times with different data, opening the browser fresh each time ensures test isolation.

2. Step 2: Evaluate other options

   Writing separate tests duplicates code, looping inside one test loses pytest reporting benefits, and opening browser only once risks test interference.

3. Final Answer:

   Use @pytest.mark.parametrize to pass username and password, then inside the test open the browser, enter credentials, and assert login success -> Option A

4. Quick Check:

   Parametrize + fresh browser per test = best practice [OK]

Hint: Parametrize inputs and open browser inside test for isolation [OK]

Common Mistakes:

• Opening browser once for all tests causing state issues
• Not using parameterize and duplicating test code
• Using loops inside tests instead of parameterize