PyTest

vibssingh

Parameterizing test with multiple data sets using Fixtures in PyTest

HOME

In this tutorial, we will parameterize the tests using fixtures. To know what is fixture, please refer to this tutorial – What is Fixture in PyTest?.

Table of Contents

  1. What is the parameterized test?
  2. Parameterization using Fixtures
  3. How to pass multiple parameters in a method using Fixtures
  4. @pytest.mark.parametrize: Parametrize test functions

What is the parameterized test?

Parameterized tests allow a developer to run the same test over and over again on different values. For example, we want to test the login page or process, with multiple input values for e.g. say 10 different username and password conditions.

Parameterization using Fixtures

It allows us to run the same test function with different sets of inputs, often by defining those inputs as fixtures.

In the below example, let us create a conftest.py file.

@pytest.fixture()
def dataload():
    print("User Profile data")
    return ["Vibha","Singh","qaautiomation.expert"]

Now, let us create a new file – test_demo1.py.

import pytest


@pytest.mark.usefixtures("dataload")
class TestExample:

    def test_edit_profile(self, dataload):
        print(dataload)
        print("First Name :", dataload[0])
        print("Surname :", dataload[1])
        print("Website :", dataload[2])

The output of the above program is

In the above example, the test_edit_profile function is parameterized using @pytest.mark.usefixtures(“dataload”). It allows you to run the same test with different input values by providing a list of tuples specifying the parameters and expected values. In this case, the test will be executed three times, each time with different values for Vibha, Singh, and qaautomation.expert.

In the example below, Chrome, Firefox and edge are used as parameters to the fixture functions with the scope as class i.e. @pytest.fixture(params=[“chrome”, “firefox”,”edge”])

In the below example, let us create a fixture in conftest.py file.

import pytest


@pytest.fixture(params=["chrome", "firefox", "edge"])
def cross_browser(request):
    if request.param == "chrome":
        print ("Browser selected is chrome")
    elif request.param == "firefox":
        print("Browser selected is firefox")
    elif request.param == "edge":
        print("Browser selected is edge")

    return request.param

Now, let us create a method in a new file – test_demo2.py.

def test_cross_browser(cross_browser):
    print(cross_browser)

The output of the above program is

How to pass multiple parameters in a method using Fixtures

In the below example, we will pass multiple parameters for a run. We can see that for the first run, the parameters used are “chrome”, “Vibha”, “Singh”, the parameters used for the second run are “firefox”, “qaautomation.expert” whereas, for the third run, it is “edge”, “QA”.

import pytest


@pytest.fixture(params=[("chrome","Vibha","Singh"), ("firefox","qaautomation.expert"), ("edge","QA")])
def multiple_parameters(request):
    return request.param

Now, let us create a method in a new file – test_demo3.py.

def test_multiple_parameters(multiple_parameters):
    print(multiple_parameters)
    print("First parameter :", multiple_parameters[0])
    print("Second parameter :", multiple_parameters[1])

The output of the above program is

@pytest.mark.parametrize: Parametrize test functions

@pytest.mark.parametrize allows one to define multiple sets of arguments and fixtures for the test function or class.

import pytest


@pytest.fixture
def arithmetic_fixture(request):
    factor = request.param
    yield factor


@pytest.mark.parametrize("arithmetic_fixture", [6, 7, 9], indirect=True)
def test_arithmetic(arithmetic_fixture):
    result1 = arithmetic_fixture * 5
    result2 = arithmetic_fixture + 11
    result3 = arithmetic_fixture - 3
    print(arithmetic_fixture)
    print("Multiplication :", result1)
    print("Addition :", result2)
    print("Subtraction :", result3)

The output of the above program is

Here, the @parameterize decorator defines three different (arithmetic_fixture) tuples so that the test_arithmetic function will run three times using them in turn.

vibssingh

What is conftest.py in PyTest?

HOME

In this tutorial, we are discussing the use of conftest.py in PyTest.

What is conftest.py in PyTest?

The conftest.py file serves as a means of providing fixtures for an entire directory. Fixtures defined in a conftest.py can be used by any test in that package without needing to import them (pytest will automatically discover them). To know more about the fixtures in PyTest, please refer to this tutorial – What is Fixture in PyTest?

We can have multiple nested directories/packages containing the tests, and each directory can have its own conftest.py with its own fixtures, adding on to the ones provided by the conftest.py files in parent directories.

Below is the sample code for conftest.py.

import pytest


@pytest.fixture
def shared_fixture():
    print("This will be executed before any test")

In test_demo1.py and test_demo2.py, we have used the shared fixture:

test_demo1.py

def test_fixture1(shared_fixture):
    print("This is the fixture main method1 for demo1 class")
    print("Good Morning")


def test_fixture2(shared_fixture):
    print("This is the fixture main method2 for demo1 class")
    print("Good AfterNoon")

test_demo2.py

def test_fixture(shared_fixture):
    print("This is the fixture main method for demo2 class")
    print("Good Evening")

Execute both the files using the below command:

pytest test_demo1.py test_demo2.py -s

The output of the above program is

In the above file – test_demo1.py, we have 2 methods and shared_fixture is called in both the methods. If we don’t want to pass shared_fixture multiple times. We can define a class and assign the fixture method to that class – @pytest.mark.usefixtures(“shared_fixture”). In that case, we don’t need to assign a fixture method to each and every method present in the class.

conftest.py

import pytest


@pytest.fixture
def shared_fixture():
    print("This will be executed before any test")
    yield
    print("This will be executed after any test")

TestExample1.py

import pytest


@pytest.mark.usefixtures("shared_fixture")
class TestExample1:

    def test_fixture1(self):
        print("This is the fixture main method1 for demo1 class")
        print("Good Morning")

    def test_fixture2(self):
        print("This is the fixture main method2 for demo1 class")
        print("Good AfterNoon")

TestExample2.py

import pytest


@pytest.mark.usefixtures("shared_fixture")
class TestExample2:

    def test_fixture(self):
        print("This is the fixture main method for demo2 class")
        print("Good Evening")

Execute both the files using the below command:

pytest -s

The output of the above program is

In the above example, we can see that before and after statement is printed for each test.

Suppose we want to run the fixture method once before the start and once at the end of the class. We need to add the below command:

import pytest


@pytest.fixture(scope="class")
def shared_fixture():
    print("This will be executed before any test")
    yield
    print("This will be executed after any test")

The output of the above program is

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

What is Fixture in PyTest?

HOME

In this tutorial, we will understand the use of Fixtures in the PyTest Framework.

What is a Fixture?

Fixtures define the steps and data that constitute the arranged phase of a test. In PyTest, they are functions we define that serve this purpose. They can also be used to define a test’s act phase; this is a powerful technique for designing more complex tests.

Fixture can be used to set up and tear down resources, such as establishing database connections, creating temporary files, initializing objects, or any other operations needed to prepare the environment for your tests.

Fixtures in pytest are created using the @pytest.fixture decorator.

Below is an example of a fixture.

import pytest

@pytest.fixture()
def setup():
    print("This will be executed before any test")


def test_fixture(setup):
    print("This is the fixture main method")

In this example, the setup fixture is defined using the @pytest.fixture decorator. It will be executed before any test. The test function (test_fixture) use this fixture as an argument.

The output of the above program is

What is yield in PyTest?

The yield statement is used in fixtures to create a setup and teardown mechanism for test resources. When a fixture contains a yield statement, the code before the yield acts as the setup code (code executed before the test), and the code after the yield acts as the teardown code (code executed after the test).

Below is an example of yield.

import pytest


@pytest.fixture()
def setup():
    print("This will be executed before any test")
    yield
    print("This will be executed after any test")


def test_fixture(setup):
    print("This is the fixture main method")

The output of the above program is

That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

PyTest Framework

Last Updated On

HOME

PyTest is a testing framework that allows users to write test codes using Python programming language. PyTest is a mature, full-featured Python testing tool that helps you write better programs.

Chapter 1 What is PyTest Framework?
Chapter 2 What is fixture in PyTest?
Chapter 3 What is conftest.py in PyTest?
Chapter 4 How to skip tests in PyTest – skip, skipIf, xfail – NEW
Chapter 5 How to generate HTML report in PyTest Framework?
Chapter 6 Parameterizing test with multiple data sets using Fixtures in PyTest
Chapter 7 PyTest Logging to print to console
Chapter8 PyTest Logging to print to a file
Chapter 9 Page Object Model Implementation of Python with Selenium – PyTest
Chapter 10 How to run Python Selenium tests in Jenkins
Chapter 11 Cross Browser Testing in PyTest – NEW
Chapter 12 Jenkinsfile Pipeline Script to run Python with Selenium – Coming Soon
Chapter 13 PyTest – BDD (Behavioural Driven Development) with Selenium
Chapter 14 Scenario Outline in PyTest – BDD
Chapter 15 Filtering by tags in PyTest-BDD – NEW
Chapter 16 Integration of Allure Report with PyTest – NEW
Chapter 17 How to run PyTest Framework in GitHub Actions – NEW
vibssingh

What is PyTest Framework?

HOME

What is Pytest Framework?

PyTest is a popular testing framework for Python. It is widely used for writing and executing unit tests, functional tests, and even complex functional testing scenarios.

pytest requires: Python 3.7+ or PyPy3.

Key features of PyTest include:

1. Fixture Support: pytest supports fixtures, which are functions that can set up and tear down resources needed for testing. This makes it easy to share setup code among multiple tests.

2. Powerful Test Discovery: pytest automatically discovers and runs test functions based on naming conventions. We don’t need to explicitly list your tests; instead, the framework discovers and executes them.

3. Parameterized Testing: We can easily perform parameterized testing using pytest, allowing us to run the same test logic with multiple sets of input data.

4. Integration with Other Tools: pytest integrates well with other tools and libraries, such as Selenium for web testing, Django for web application testing, integrate report generation and more.

5. Assertions: pytest allows us to use the standard Python assert for verifying expectations and values in Python tests. 

6. Advanced Test Execution: pytest provides rich features for executing tests, including parallel test execution, selective test execution, and rerunning failed tests.

How to install PyTest?

We need to make sure that Python is already installed. If not, then please refer to this tutorial - How to Install Python on Windows 11.

If you need help in installing PyCharms, please refer to this tutorial – How to install PyCharms on Windows 11.

To install pytest, use the below command:

pip install pytest

Create a PyTest test

Create a new project folder and open it in PyCharm.

Go to the project folder and Create a new Python file, name it “sample_test.py”.

Create tests in the Python file.

def test_addition():
    a = 6
    b = 5
    c = 11

    assert a + b == 11, "Sum is not 11"
    assert a + b == c, "Sum of a and b is not equal to c"


def test_subtraction():
    x = 15
    y = 4
    z = 18

    assert x - y == z, "Subtract y from x is equal to z"

To run the tests, use the below command:

pytest

This command will run all the test file which has *test* in its name. Here, we have 1 Python file named as Sample_test.py. This file has 2 test, one of the test passes and another one fails. In the failures section, we can see the failed method(s) and the line of failure. Here x-y=z means 15-4=10 which is false.

The output of the above execution is

How PyTest Identifies the Test Files and Test Methods

By default pytest only identifies the file names starting with test_ or ending with _test as the test files. We can explicitly mention other filenames though (explained later). Pytest requires the test method names to start with “test.” All other method names will be ignored even if we explicitly ask to run those methods.

See some examples of valid and invalid pytest file names

test_sample - valid
sample_test - valid
sample_tests - invalid
testsample - invalid
sampletest - invalid

 We can explicitly ask pytest to pick sample_tests.py, testsample.py and sampletest.py.