PyTest

vibssingh

Integration of Allure Report with PyTest

Last Updated on

HOME

In this tutorial, we will discuss the Integration of Allure Report with the PyTest.

Table of Contents:

  1. What is an Allure Report?
  2. Prerequisite
  3. Implementation Steps
    1. Install allure-pytest plugin
    2. Create a new project folder and open it in PyCharm
    3. Add the allure-pytest package to the PyCharms
    4. Create the test code
    5. Execute the tests
    6. Generation of allure-results folder
    7. Generate the Allure Report
    8. Allure Report Dashboard
      1. Categories in Allure Report
      2. Suites in Allure Report
      3. Graphs in Allure Report
      4. Timeline in Allure Report
      5. Behaviours of Allure Report
      6. Packages in Allure Report

What is an Allure Report?

Allure Framework is a flexible lightweight multi-language test report tool that not only shows a very concise representation of what has been tested in a neat web report form but allows everyone participating in the development process to extract maximum useful information from everyday execution of tests.

From the dev/qa perspective, Allure reports shorten common defect lifecycle: test failures can be divided into bugs and broken tests, also logs, steps, fixtures, attachments, timings, history, and integrations with TMS and bug-tracking systems can be configured, so the responsible developers and testers will have all information at hand.

Prerequisite:

  1. Python is installed on the machine
  2. PIP is installed on the machine
  3. PyCharm or another Python Editor is installed on the machine

    If you need help installing Python, please refer to this tutorial – How to Install Python on Windows 11.

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

    Implementation Steps:

    Step 1 – Install allure-pytest plugin

    Go to the command prompt and run the below-mentioned command to download the plugin:

    pip install allure-pytest

    The below image shows that the plugin is installed successfully.

    Step 2 – Create a new project folder and open it in PyCharm

    Step 3 – Add the allure-pytest package to the PyCharms

    Go to File->Settings ->Project:PageObjectModel_Pytest->Python Interpreter.

    Click on the “+” sign and enter allure-pytest in the search bar. It will show a list of packages. Select the “allure-pytest” package and click on the “Install Package”.

    Once the package is installed, we will see the message that the package is installed successfully, and it can be seen under the package list as shown below:

    Step 4 – Create the test code

    The complete PyTest framework can be found here – Page Object Model Implementation of Python with Selenium – PyTest.

    Step 5 – Execute the tests

    We need the below command to run the PyTest Framework script using the Allure listener.

    pytest --alluredir allure-results

    The output of the above program is

    Step 6 – Generation of allure-results folder

    We have the test case passed. It will generate an allure-results folder in the tests directory. This folder contains all the files needed to generate the Allure Report.

    Step 7 – Generate the Allure Report

    To create Allure Report, use the below command

    allure serve allure-results

    This will generate the beautiful Allure Test Report as shown below.

    Step 8 – Allure Report Dashboard

    The overview page hosts several default widgets representing the basic characteristics of your project and test environment.

    1. Statistics – overall report statistics.
    2. Launches – if this report represents several test launches, statistics per launch will be shown here.
    3. Behaviours – information on results aggregated according to stories and features.
    4. Executors – information on test executors that were used to run the tests.
    5. History Trend – if tests accumulated some historical data, it’s trend will be calculated and shown on the graph.
    6. Environment – information on the test environment.

    Categories in Allure Report

    The categories tab gives you a way to create custom defect classifications to apply for test results. There are two categories of defects – Product Defects (failed tests) and Test Defects (broken tests).

    Suites in Allure Report

    On the Suites tab a standard structural representation of executed tests, grouped by suites and classes can be found.

    Graphs in Allure Report

    Graphs allow you to see different statistics collected from the test data: statuses breakdown or severity and duration diagrams.

    Timeline in Allure Report

    The timeline tab visualizes retrospective of tests execution, allure adaptors collect precise timings of tests, and here on this tab, they are arranged accordingly to their sequential or parallel timing structure.

    Behaviours of Allure Report

    This tab groups test results according to Epic, Feature, and Story tags.

    Packages in Allure Report

    The packages tab represents a tree-like layout of test results, grouped by different packages.

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

    vibssingh

    Cross Browser Testing in PyTest

    HOME

    In this tutorial, we’ll explore how to carry out Cross-Browser testing using PyTest.

    Table of Contents

    1. What is Cross-Browser Testing?
    2. Why do we need to perform Cross Browser Testing?
    3. Prerequisite
    4. Implementation Steps
      1. Parameterize the test in conftest.py
      2. Create the tests
      3. Execute the tests

    What is Cross-Browser Testing?

    Cross Browser is a technique in which a web application tests on different browsers and operating systems.  Cross Browser testing, make sure that the site is rendered the same in every browser and operating system, and ensure that the users have a good experience.

    Why do we need to perform Cross Browser Testing?

    User Experience Consistency: Different browsers can render web content differently. Cross-browser testing ensures that users have a consistent and reliable experience regardless of the browser they choose.

    Browser-Specific Issues: Each browser has its quirks, bugs, and features. Different browser is compatible with different operating systems. Cross-browser testing helps identify and address browser-specific issues or inconsistencies that may affect functionality or appearance.

    Prerequisite:

    1. Python is installed on the machine
    2. PIP is installed on the machine
    3. PyCharm or another Python Editor is installed on the machine

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

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

    Implementation Steps

    1. Parameterize the test in conftest.py

    PyTest allows easy parameterization of tests. To run a test against a list of browsers, we can pass the browser_name through the command line.

    import pytest
from selenium import webdriver


def pytest_addoption(parser):
    """Custom Pytest command line options"""
    parser.addoption(
        "--browser_name", action="store", default="chrome"
    )


@pytest.fixture(scope="class")
def driver(request):

    browser_name = request.config.getoption("browser_name")

    if browser_name == "chrome":
        options = webdriver.ChromeOptions()
        driver = webdriver.Chrome(options)
        print("Chrome Browser is opened")
    elif browser_name == "firefox":
        options = webdriver.FirefoxOptions()
        driver = webdriver.Firefox(options)
        print("Firefox Browser is opened")
    elif browser_name == "edge":
        options = webdriver.EdgeOptions()
        driver = webdriver.Edge(options)
        print("Edge Browser is opened")
    else:
        print("No browser is selected")
    driver.get("https://opensource-demo.orangehrmlive.com/")
    driver.maximize_window()
    driver.implicitly_wait(5)
    yield driver
    driver.close()

    If we do not pass any browser_name through the command line, then the test will run by default using Chrome.

    2. Create the tests

    Below is an example of the test.

    from selenium.webdriver.common.by import By


class Test_Login:

    def test_login(self,driver):
        driver.find_element(By.NAME, "username").send_keys("Admin")
        driver.find_element(By.NAME, "password").send_keys("admin123")
        driver.find_element(By.XPATH, "//*[@class='oxd-form']/div[3]/button").click()
        print("Successful login to the application")
        homePageTitle = driver.find_element(By.XPATH, "//*[@class='oxd-topbar-header-breadcrumb']/h6").text
        print("Heading of DashBoard Page: ", homePageTitle)
        assert homePageTitle == "Dashboard", "Heading is different"

    3. Execute the tests

    To run the tests through the command line, use the below command:

    pytest test_login.py -s

    This will execute the tests on the Chrome browser, as we have not passed any browser_name through the command line.

    The output of the above program is

    If we want to run the tests on the firefox browser, then use the below command:

     pytest test_login.py --browser_name firefox -s

    The output of the above program is

    Similarly, we can execute the tests in the edge browser by just changing the browser_name in the command line.

    Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

    vibssingh

    How to skip tests in PyTest – skip, skipIf, xfail

    HOME

    In this tutorial, we will learn how to skip specific tests in PyTest. Sometimes, you might want a test to run only under certain conditions. If those conditions are not met, skipping the test ensures it doesn’t run unnecessarily, saving time and resources.

    A skip indicates that a test should only proceed if specific conditions are satisfied; otherwise, pytest should bypass running the test entirely. Common examples are skipping windows-only tests on non-windows platforms, or skipping tests that depend on an external resource which is not available at the moment (for example a database).

    When you use the pytest.skip() function within a test or setup function, pytest will skip that particular test or the entire test function.

    An xfail means that you expect a test to fail for some reason. A common example is a test for a feature not yet implemented, or a bug not yet fixed. When a test passes despite being expected to fail (marked with pytest.mark.xfail), it’s an xpass and will be reported in the test summary.

    pytest counts and lists skip and xfail tests separately. 

    import pytest


@pytest.mark.skip(reason="In Progress")
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"


@pytest.mark.skipif(15-4>10, reason="Conditional")
def test_subtraction():
    x = 15
    y = 4
    z = 10

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


@pytest.mark.xfail
def test_multiplication():
    a = 6
    b = 5
    c = 30

    assert a * b == c, "Product of 5 and 6 is not 30"


def test_division():
    a = 16
    b = 2
    c = 8

    assert a / b == c, "Division of 2 by 6 is not 3"

    To run these tests, use the below command:

    pytest test_skip_demo.py

    The output of the above program is

    As we can see in the above example, there are total of 4 tests. 1 test is marked as skip, another test is marked as skipif (the condition of skipif is satisfied, so this test also skips), 3rd tests is marked as xfail and remaining 1 test is passed. Here, I have generated a report also to see the output in the report.html. In this report, Unexpected passes represent the xfail.

    Skip all test functions of a class or module

    You can also skip all tests in a module or class using the pytest.mark.skip decorator.

    import pytest


@pytest.mark.skip("Development in progress")
class test_skip_class:

    def test_addition(self):
        a = 10.44
        b = 5.56
        c = 16.00

        assert a + b == 16.00, "Sum is not 16"

    def test_subtraction(self):
        x = 15
        y = 4
        z = 10

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

    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

    Filtering by tags in PyTest-BDD

    Last Updated On

    HOME

    In certain situations, rather than running the entire test suite, we might need to execute only a specific test. In such cases, we can use tags to filter and select the desired scenarios for execution. pytest-bdd also supports tagging through options like -k or -m for filtering tests based on tags.

    Below are 2 feature files.

    Login.feature

    @Login
Feature: Login Page

    @ValidCredentials
    Scenario: Successful Application Login
        Given User is on login page
        When User enter username "Admin" and password "admin123"
        Then User should be able to login successfully and new page open "Dashboard"

    ScenarioOutline.feature

    @ScenarioOutline
Feature: Scenario Outline Example

    @InvalidCredentials
    Scenario Outline: Invalid credentials generate error message
        Given User is on OrangeHome page
        When User enters username as "<username>" and password as "<password>"
        Then User should be able to see error message as "Invalid credentials"

      Examples:
       | username | password    |
       | admin    | admin12345  |
       | Admin123 | admin       |
       | 123      | admin       |


    @MissingUsername
    Scenario: Missing Username generates error
        Given User is on OrangeHome page
        When User enters username as " " and password as "admin123"
        Then User should be able to see error message as "Required" below the username field

    Run Test from Command Line

    1. Running all the tests

    To run all the scenarios, we can open the command prompt and use the below command:-

    pytest

    This command will execute all the scenarios present in all the feature files. We can see that there are warning summaries like PytestUnknownMarkWarning: Unknown pytest.mark.ValidCredentials – is this a type? You can register custom marks to avoid this warning. To know more about this, you can refer to this document – How to mark test functions with attributes.

    To avoid these types of warnings, I suggest you create a pytest.ini file and save it in the project. We need to mention all the markers and their description in this file.

    [pytest]
markers =
    Login: mark all tests as login
    ValidCredentials: mark a test as a valid credentials (deselect with '-m "not ValidCredentials"')
	ScenarioOutline: mark all tests as ScenarioOutline
	InvalidCredentials: mark test as invalid credentials (deselect with '-m "not InvalidCredentials"')
	MissingUsername: mark test as missing username (deselect with '-m "not MissingUsername"')

    2. Running Scenarios using Tags

    If you want to run a subset of scenarios tagged with @MissingUsername. In this case, we want to run a specific scenario – @MissingUsername.

     pytest -k "MissingUsername"

    The output of the above program is

    3. Running a Feature file

    Suppose you want to run a single Feature File from the command line, then use the below syntax

    pytest -k  "Login"

    The output of the above program is

    4. Passing multiple Parameters

    If we want to pass more than one parameter, then we can use the following command. In this case, we are using the “and” command.

    pytest -m "ScenarioOutline and MissingUsername"

    The output of the above program is

    OR Command

    Imagine you want to execute any one of the scenarios, then we can use the “OR” command.

    pytest -m "ValidCredentials or MissingUsername"

    The output of the above program is

    5. Negative Command

    Here, we have a total of 5 tests, and we will execute 2 tests as I have used “@InvalidCredentials” which has 3 tests. So, not using this tag means rest 2 tests will be executed.

     pytest -m "not InvalidCredentials"

    The output of the above program is

    These are some commonly used tags in PyTest.

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

    vibssingh

    Scenario Outline in PyTest – BDD

    Last Updated On

    HOME

    In this tutorial, we will create a Scenario Outline in PyTest-BDD.

    Prerequisite:

    1. Python is installed on the machine
    2. PIP is installed on the machine
    3. PyCharm or other Python Editor is installed on the machine

    If you need help in installing Python, 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.

    What is Scenario Outline?

    Scenarios can be parametrized to cover multiple cases. These are called Scenario Outlines in Gherkin, and the variable templates are written using angular brackets (e.g. <name>). It allows us to define a scenario template with placeholders for parameters, and then specify multiple examples of that scenario using different values for those parameters.

    Here’s an example of a Scenario Outline:

    In this Scenario Outline:

    <username> and <password> are placeholders for parameters. The Examples section provides multiple sets of values for these parameters. Each set of values represents a different example of the scenario.

    How to implement Scenario Outline in PyTest – BDD?

    Project Structure

    Implementation Steps

    Step 1 – Install pytest

    Use the below command to install PyTest on your machine.

    pip install pytest
pip install pytest-bdd
pip install pytest-selenium (If using Selenium)

    Step 2 – Create a new project in PyCharm

    Create a new project folder and open it in PyCharm.

    Step 3 – Create a new directory

    Go to the project folder and create a new directory – tests.

    Step 4 – Create python directories

    Go to the test directory and create a new directory within it – features and another Python directory – stepdefinitions.

    Step 5 – Add pytest-selenium and pytest-bdd packages to the PyCharms

    Go to File->Settings ->Project: PyTest-BDD_Demo->Python Interpreter.

    Click on the “+” sign and enter allure-r in the search bar. It will show a list of packages. Select the “pytest-selenium” package and click on the “Install Package”.

    Once the package is installed, we will see the message that the package is installed successfully.

    Step 6 – Create a feature file

    Create a feature file – ScenarioOutline.feature in the features directory.

    Below is the sample feature file that contains Scenario Outline .

    Feature: Scenario Outline Example

    @InvalidCredentials
    Scenario Outline: Unsuccessful Application Login
        Given User is on OrangeHome page
        When User enters username as "<username>" and password as "<password>"
        Then User should be able to see error message as "Invalid credentials"

      Examples:
       | username | password    |
       | admin    | admin12345  |
       | Admin123 | admin       |
       | 123      | admin       |

    Step 7 – Create the test code in stepdefinitions directory

    The stepdefinition of the ScenarioOutline.feature file is created in stepdefinitions directory – test_scenario_outline_definitions.py.

    Below is the sample code.

    import pytest

from pytest_bdd import scenarios, given, when, then, parsers
from selenium import webdriver
from selenium.webdriver.common.by import By


# Constants
TIMEOUT = 5
URL = 'https://opensource-demo.orangehrmlive.com/'


# Scenarios
scenarios('../features/ScenarioOutline.feature')


# Fixtures
@pytest.fixture
def driver():
    driver = webdriver.Firefox()
    driver.implicitly_wait(TIMEOUT)
    driver.maximize_window()
    yield driver
    driver.quit()


# Given Steps
@given('User is on OrangeHome page')
def open_browser(driver):
    driver.get(URL)


# When Steps
@when(parsers.parse('User enters username as "{username}" and password as "{password}"'))
def search_phrase(driver, username, password):
    driver.find_element(By.NAME, "username").send_keys(username)
    driver.find_element(By.NAME, "password").send_keys(password)
    driver.find_element(By.XPATH, "//*[@class='oxd-form']/div[3]/button").click()


# Then Steps
@then(parsers.parse('User should be able to see error message as "{expected_error_message}"'))
def search_results(driver, expected_error_message):
    actual_error_message = driver.find_element(By.XPATH, "//*[@id='app']/div[1]/div/div[1]/div/div[2]/div[2]/div/div[1]/div[1]/p").text
    assert actual_error_message == expected_error_message

    To bind all scenarios found in the ScenarioOutline.feature, we need to use the below syntax:

    scenarios('../features/ScenarioOutline.feature')

    Step 8 – Execute the tests

    As we know that the stepdefinitions file is present in the tests directory, so to run this test, use the below command:

    pytest stepdefinitions/test_scenario_outline_definitions.py -s

    The output of the above execution is

    Step 9 – Generate the HTML Report

    To generate a HTML Report, please refer to this tutorial – How to generate HTML Report in PyTest Framework.

    Generate a HTML Report using the below command:

     pytest stepdefinitions/test_scenario_outline_definitions.py --html=Report.html

    The Report.html report will be generated in the root directory.

    Step 10 – View the HTML report

    Right-click and open with Web Browser.

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

    vibssingh

    PyTest – BDD (Behavioural Driven Development) with Selenium

    Last Updated On

    HOME

    In this tutorial, we will create a PyTest test with Selenium in BDD (Behavioural Driven Development).

    Prerequisite:

    1. Python is installed on the machine
    2. PIP is installed on the machine
    3. PyCharm or another Python Editor is installed on the machine

    If you need help installing Python, please refer to this tutorial – How to Install Python on Windows 11.

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

    What is PyTest – BDD?

    Pytest BDD is a behaviour-driven development (BDD) framework for writing tests in Python using the pytest testing framework. It combines the simplicity and power of the pytest framework with the expressive syntax of the Gherkin language used in BDD.

    pytest-bdd is a pytest plugin that allows you to write behaviour-driven development (BDD) style tests using the Gherkin syntax. Unlike many other BDD tools, it does not require a separate runner and benefits from the power and flexibility of pytest. It enables unifying unit and functional tests, reduces the burden of continuous integration server configuration, and allows the reuse of test setups.

    Project Structure

    Implementation Steps

    Step 1 – Install pytest

    Use the below command to install PyTest on your machine.

    pip install pytest

    Step 2 – Install pytest-bdd

    Use the below command to install PyTest on your machine.

    pip install pytest-bdd

    Step 3 – Install pytest-selenium

    Use the below command to install pytest-selenium plugin on your machine.

    pip install pytest-selenium

    Step 4 – Create a new project in PyCharm

    Create a new project folder and open it in PyCharm.

    Step 5 – Create a new directory

    Go to the project folder and create a new directory – tests.

    Step 6 – Create python directories

    Go to the test directory and create a new directory within it – features and another Python directory – stepdefinitions.

    Step 7 – Add pytest-selenium and pytest-bdd packages to the PyCharms

    Go to File->Settings ->Project: PyTest-BDD_Demo->Python Interpreter.

    Click on the “+” sign and enter allure-r in the search bar. It will show a list of packages. Select the “pytest-selenium” package and click on the “Install Package”.

    Once the package is installed, we will see the message that the package is installed successfully.

    Step 8 – Create a feature file

    Create a feature file – Login.feature in the features directory.

    Below is the sample feature file.

    Feature: Login Page

    Scenario: Successful Application Login
        Given User is on login page
        When User enter username "Admin" and password "admin123"
        Then User should be able to login successfully and new page open "Dashboard"

    Step 9 – Create the test code in stepdefinitions directory

    The step definition of the Login.feature file is created in the stepdefinitions directory – test_login_definitions.py.

    Below is the sample code.

    import pytest

from pytest_bdd import scenarios, given, when, then, parsers
from selenium import webdriver
from selenium.webdriver.common.by import By

# Constants
TIMEOUT = 4
URL = 'https://opensource-demo.orangehrmlive.com/'


# Scenarios
scenarios('../features/Login.feature')


# Fixtures
@pytest.fixture
def driver():
    driver = webdriver.Firefox()
    driver.implicitly_wait(TIMEOUT)
    driver.maximize_window()
    yield driver
    driver.quit()


# Given Steps
@given('User is on login page')
def open_browser(driver):
    driver.get(URL)


# When Steps
@when(parsers.parse('User enter username "{username}" and password "{password}"'))
def search_phrase(driver, username, password):
    driver.find_element(By.NAME, "username").send_keys(username)
    driver.find_element(By.NAME, "password").send_keys(password)
    driver.find_element(By.XPATH, "//*[@class='oxd-form']/div[3]/button").click()


# Then Steps
@then(parsers.parse('User should be able to login successfully and new page open "{heading}"'))
def search_results(driver, heading):
    homepage_title = driver.find_element(By.XPATH, "//*[@class='oxd-topbar-header-breadcrumb']/h6").text
    assert homepage_title == heading

    To bind all scenarios found in the Login.feature, we need to use the below syntax:

    scenarios('../features/Login.feature')

    Step 10 – Execute the tests

    As we know the stepdefinitions file is present in the tests directory, so to run this test, use the below command:

    pytest tests

    The output of the above execution is

    Step 11 – Generate the HTML Report

    To generate an HTML Report, please refer to this tutorial – How to generate HTML Report in PyTest Framework.

    Generate an HTML Report using the below command:

    pytest tests --html=Report.html -s

    The Report.html report will be generated in the root directory.

    Step 12 – View the HTML report

    Right-click and open with Web Browser.

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

    vibssingh

    How to run Python Selenium tests with Jenkins

    Last Updated On

    HOME

    In the previous tutorial, we have seen the How to generate HTML Reports in Jenkins. In this tutorial, we show you how to integrate PyTest tests with Jenkins. 

    Table Of Contents

    1. Prerequisite
    2. Implementation Steps
      1. Create a new FreeStyle project
      2. Select a custom workspace
      3. Build Management
      4. Select “Publish HTML reports” from “Post Build Actions”
      5. Execute the tests
      6. View the HTML Report

    Prerequisite:

    Jenkin’s installed and started on the computer. The current Jenkins version is – 2.361.2

    Implementation Steps

    To generate HTML Report in Jenkins, we need to download HTML Publisher Plugin. Please refer to this tutorial to install the plugin – How to install Plugins in Jenkins.

    Step 1: Create a new FreeStyle project

    1. Give the Name of the project – PyTestFramework_Demo
    2. Click on the Freestyle project. 
    3. Click on the OK button.

    In the General section, enter the project description in the Description box – This is demo integration of Python with Selenium tests to run in Jenkins.

    Step 2: Select a custom workspace

    Mention the full path of the project in the Use custom workspace.

    Select Source Code Management as None if the project is locally present on the machine.

    Step 3: Build Management

    The source code used for this tutorial can be seen here –  Page Object Model Implementation of Python with Selenium – PyTest.

    Go to the Build section of the new job. Select “Execute Windows batch command”.

    Mention the command needed to execute the tests. In this case, I have to execute all the tests, so used the below command:

    cd tests
pytest  --html=$WORKSPACE/Reports/report.html -s

    We have tests present in test directory. So we have used cd tests.

    $WORKSPACE is the environment variable. It provides the absolute path of the workspace.

    Step 4: Select “Publish HTML reports” from “Post Build Actions”

    Scroll down to “Post Build Actions” and click on the “Add Post Build Actions” drop-down list. Select “Publish HTML reports“. 

    If you want to see where the report will be saved in Jenkins, go to the Dashboard -> PyTestFramework_Demo -> Workspace -> Reports ->report.html.

    This can be only viewed once the project is built and the job is executed. Then go to Workspace to check the location of the report.html file.

    Enter the HTML directory to archive – Reports, Index page[s] – report.html, and Report title – HTML Report.

    Click on the Apply and Save buttons.

    We have created a new FreeStyle project “PyTestFramework_Demo” with the configuration to run the Python tests in windows batch.

    Step 5: Execute the tests

    Let’s execute it now by clicking on the “Build Now” button. 

    Right-click on Build Number (here in my case it is #1).

    Click on Console Output to see the result.

    Step 6: View the HTML Report

    Once the execution is completed, click on go “Back to Project“, and we could see a link to view the “HTML Report“.

    We can see here that the HTML Report link is displayed in the Console.

    Below is the HTML Report generated in Jenkins.

    There are chances that the report won’t look very pretty. The reason is that CSS is stripped out because of the Content Security Policy in Jenkins.

    The default rule set in Jenkins is:

    sandbox; default-src 'none'; img-src 'self'; style-src 'self';

    To know more about this, please refer to this tutorial – https://www.jenkins.io/doc/book/security/configuring-content-security-policy/.

    We can customize Content Security Policy in Jenkins. But keep in mind that it should be done after checking with the Security team in your organization. This is a workaround solution. I can’t emphasize enough that this is not a standard practice.

    Go to Manage Jenkins -> Manage Nodes and Clouds.

    Click on the Script Console option.

    Type in the following command and Press Run. If you see the output as ‘Result:’ then the protection is disabled. Re-Run your build and you can see that the new HTML files archived will have the CSS enabled.

    System.setProperty("hudson.model.DirectoryBrowserSupport.CSP","")

    Re-run the HTMLReport_Demo project. Now you can see a properly rendered HTML Report.

    Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

    Additional Tutorials

    How to Install Python on Windows 11
    How to install and setup Robot Framework for Python
    How to rerun failed tests in Robot Framework
    How to implement tagging in Robot Framework
     How to set variable values from Runtime command in Robot Framework
    How to load data from CSV files in the Robot Framework?
    vibssingh

    Page Object Model Implementation of Python with Selenium – PyTest

    Last Updated On

    HOME

    In this tutorial, we will create a Page Object Model framework using PyTest(Python).

    Prerequisite:

    1. Python is installed on the machine
    2. PIP is installed on the machine
    3. PyCharm or other Python Editor is installed on the machine

    If you need help in installing Python, 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.

    What is Page Object Model?

    The Page Object Model (POM) is a design pattern used in test automation, particularly in web application testing. It aims to enhance the test automation framework’s maintainability, readability, and reusability by encapsulating the behavior of web pages or user interfaces into separate classes or modules called Page Objects.

    In essence, the Page Object Model represents web pages or user interfaces as objects in the test automation code. Each page or UI element is associated with a Page Object, which contains all the actions that can be performed on that page and the elements present on it.

    To implement the Page Object Model (POM) in PyTest, we will organize the test cases and page objects in a way that promotes reusability, readability, and maintainability.

    1. Create Page Objects: Define a separate class for each page of your web application. Each class should encapsulate the elements and actions of the corresponding page.
    2. Write Test Cases: Implement your test cases as pytest test functions or methods. These test functions should interact with the page objects to perform actions and assertions.
    3. Use Fixtures for Setup and Teardown: Utilize pytest fixtures for setup and teardown operations such as initializing the browser, navigating to URLs, and closing the browser.

    Project Structure

    Implementation Steps

    Step 1 – Install pytest

    Use the below command to install PyTest on your machine.

    pip install -U pytest

    Step 2 – Create a new project in PyCharm

    Create a new project folder and open it in PyCharm.

    Step 3 – Create python directories

    Go to the project folder and create 2 new python directories for pages and tests respectively.

    Step 4 – Add pytest-selenium package to the PyCharms

    Go to File->Settings ->Project: PageObjectModel_PyTest->Python Interpreter.

    Click on the “+” sign and enter allure-r in the search bar. It will show a list of packages. Select the “pytest-selenium” package and click on the “Install Package”.

    Once the package is installed, we will see the message that the package is installed successfully.

    Step 5 – Create the test code and corresponding helper classes

    First we will create BasePage class that contains all the generic methods that will be used throughout the framework, like driver method, locator method and soon.

    from selenium.webdriver import ActionChains
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as ec


class BasePage:

    def __init__(self, driver):
        self._driver = driver
        self._wait = WebDriverWait(self._driver, 10)
        self._action = ActionChains(self._driver)

    def find(self, locator):
        return self._driver.find_element(*locator)

    Now, we will create the page object class of each page.

    LoginPage.py

    from selenium.webdriver.common.by import By

from pages.base_page import BasePage


class LoginPage(BasePage):
    username = (By.NAME, "username")
    password = (By.NAME, "password")
    submit_button = (By.XPATH, "//*[@class='oxd-form']/div[3]/button")
    error_message = (By.XPATH, "//*[@class='orangehrm-login-error']/div[1]/div[1]/p")

    def execute_login(self, username: str, password: str):
        self.find(self.username).send_keys(username)
        self.find(self.password).send_keys(password)
        self.find(self.submit_button).click()

    def actual_error(self):
        return self.find(self.error_message).text

    DashboardPage.py

    from selenium.webdriver.common.by import By

from pages.base_page import BasePage


class DashboardPage(BasePage):
    heading = (By.XPATH, "//*[@class='oxd-topbar-header-breadcrumb']/h6")
    assign_leave_option = (By.XPATH, "//*[@title='Assign Leave']")
    time_at_work_option = (By.XPATH, "//*[@title='Time at Work']")

    def actual_heading(self):
        return self.find(self.heading).text

    def assign_leave_displayed(self):
        return self.find(self.assign_leave_option).is_displayed()

    def time_at_work_displayed(self):
        return self.find(self.assign_leave_option).is_displayed()

    Now, we will create a conftest.py class that contains the initialization of the browser.

    import pytest
from selenium import webdriver


@pytest.fixture(scope="class")
def driver():

    driver = webdriver.Chrome()
    driver.get("https://opensource-demo.orangehrmlive.com/")
    driver.maximize_window()
    driver.implicitly_wait(2)
    yield driver
    driver.close()

    Below are the test classes for the Login Page and Dashboard page.

    test_login_page.py

    import pytest

from pages.dashboard_page import DashboardPage
from pages.login_page import LoginPage


def test_login_negative(driver, get_data):

    login_page = LoginPage(driver)
    login_page.execute_login(get_data["username"], get_data["password"])
    assert login_page.actual_error() == "Invalid credentials", "Error message does not match expected value"


def test_login_positive(driver):
    login_page = LoginPage(driver)
    login_page.execute_login("Admin", "admin123")
    dashboard_page = DashboardPage(driver)
    assert dashboard_page.actual_heading() == "Dashboard", "Heading is different"

@pytest.fixture(params=[{"username":"admin", "password":"admin$$"},
                        {"username":"Admin123", "password":"123"}])
def get_data(request):
    return request.param

    test_dashboard_page.py

    from pages.dashboard_page import DashboardPage
from pages.login_page import LoginPage


def test_successful_login(driver):

    login_page = LoginPage(driver)
    login_page.execute_login("Admin", "admin123")
    dashboard_page = DashboardPage(driver)
    assert dashboard_page.actual_heading() == "Dashboard"


def test_time_at_work(driver):
    login_page = LoginPage(driver)
    login_page.execute_login("Admin", "admin123")
    dashboard_page = DashboardPage(driver)
    assert dashboard_page.time_at_work_displayed()

    Step 6 – Execute the tests

    To run this test, use the below command:

    pytest

    The output of the above execution is

    Step 7 – Generate the HTML Report

    To generate a HTML Report, please refer to this tutorial – How to generate HTML Report in PyTest Framework.

    Generate a HTML Report using the below command:

     pytest --html=report.html -s

    The report.html report will be generated in the root directory.

    Step 8 – View the HTML report

    Right-click and open with Web Browser.

    The complete code can be found in GitHub – vibssingh/PyTest_Framework.

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

    vibssingh

    Pytest Logging to print to a File

    HOME


    Logging function is used as a method for monitoring events in order to identify software issues as they occur.

    While Pytest excels at executing tests, it doesn’t inherently showcase the results of print statements or logs, posing a challenge when diagnosing test failures.

    So, what’s the remedy? How can we effectively log and observe events in real-time during our unit testing?

    The solution lies in PyTest logging, offering the capability to generate and even modify log handlers within PyTest.

    The file logger utilizes logging.FileHandler() to direct logs to a specified file. It’s also set to the INFO level, ensuring uniformity of logged information across the console and file outputs.

    Below is an example of File Logger.

    import logging


def test_logging_file():

    # Create a named logger
    logger = logging.getLogger(__name__)

    # Create a file handler
    filehandler = logging.FileHandler('logfile.log')

    # Set the formatter for the file handler
    formatter = logging.Formatter("%(asctime)s : %(levelname)s : %(name)s : %(message)s")
    filehandler.setFormatter(formatter)

    # Add the file handler to the logger
    logger.addHandler(filehandler)  

    logger.setLevel(logging.INFO)
    logger.debug("Debug statement is executed")
    logger.info("Information statement is executed")
    logger.warning("Warning mode, but test continues")
    logger.error("Error has happened and failed the test")
    logger.critical("Critical issue")

    By default each captured log message shows the module, line number, log level and message.

    If desired the log and date format can be specified to anything that the logging module supports by passing specific formatting options:

    logging.Formatter("%(asctime)s : %(levelname)s : %(name)s : %(message)s")

    We can run the test by right clicking on the program and select Run ‘Python tests for test_logging_file’.

    We can also run by using the below command in the terminal:

    pytest test_logging_file.py -s

    The output of the above program is

    The file is created in demo as the test file is there.

    Below is an example of logfile.log.

    How to integrate logging in PyTest tests?

    Let us create a BaseClass and mention the logging function there.

    import inspect
import logging


class BaseClass:

    def get_logger(self):

        loggerName = inspect.stack()[1][3]
        logger = logging.getLogger(loggerName)

        filehandler = logging.FileHandler('logfile.log')

        formatter = logging.Formatter("%(asctime)s : %(levelname)s : %(name)s : %(message)s")
        filehandler.setFormatter(formatter)

        logger.addHandler(filehandler)  

        logger.setLevel(logging.INFO)
        return logger

    We are creating a PyTest class that contains the test as will as will inherit the BaseClass.

    import pytest
from demo.BaseClass import BaseClass


class TestExample3(BaseClass):

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

    @pytest.mark.usefixtures("dataload")
    def test_user_profile(self, dataload):
        log = self.get_logger()
        log.info(dataload)
        log.info(f'First Name : {dataload[0]}')
        log.info(f'Surname : {dataload[1]}')
        log.info(f'Website : {dataload[2]}')

    Run the test using the below command:

    pytest -s

    The output of the above program is

    The output of the logfile.log is

    We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    vibssingh

    Pytest Logging to print to Console

    HOME


    Logging function is used as a method for monitoring events in order to identify software issues as they occur.

    While Pytest excels at executing tests, it doesn’t inherently showcase the results of print statements or logs, posing a challenge when diagnosing test failures.

    So, what’s the remedy? How can we effectively log and observe events in real-time during our unit testing?

    The solution lies in Pytest logging, offering the capability to generate and even modify log handlers within Pytest.


    The Python built-in logging module offers five standard levels that signify the severity of events:

    • NOTSET (0): This level captures all messages, irrespective of their severity.
    • DEBUG (10): Used for information aiding in identifying potential issues, such as variable values or program execution steps.
    • INFO (20): Confirms that operations are proceeding as intended.
    • WARNING (30): Indicates an unexpected event or potential issue in the near future (e.g., low disk space), but the software continues to function normally.
    • ERROR (40): Signifies a significant problem that has hindered the software from executing a specific function.
    • CRITICAL (50): Denotes an extremely severe error that could halt the program’s execution entirely.

    Console Logger

    The console logger leverages logging.StreamHandler() to output logs to the console (stdout). The logger’s level is set to INFO, meaning it will handle all log messages with a severity of INFO and above.

    Below is an example of Console Logger.

    import logging


def test_logging_console():
    logger = logging.getLogger(__name__)

    # Create a console handler
    console_handler = logging.StreamHandler()

    # Set the formatter for the console handler
    formatter = logging.Formatter("%(asctime)s : %(levelname)s : %(name)s : %(message)s")
    console_handler.setFormatter(formatter)

    # Add the console handler to the logger
    logger.addHandler(console_handler)
    logger.setLevel(logging.INFO)

    logger.debug("Debug statement is executed")
    logger.info("Information statement is executed")
    logger.warning("Warning mode, but test continues")
    logger.error("Error has happened and failed the test")
    logger.critical("Critical issue")

    By default each captured log message shows the module, line number, log level and message.

    If desired the log and date format can be specified to anything that the logging module supports by passing specific formatting options:

    logging.Formatter("%(asctime)s : %(levelname)s : %(name)s : %(message)s")

    We can run the test by right clicking on the program and select Run ‘Python tests for test_logging_console’.

    We can also run by using the below command in the terminal:

    pytest test_logging_console.py -s

    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!!