Forem: JoliveHodehou

Python ConfigParser Tutorial – Comprehensive Guide To Working With Configuration Files With Python

JoliveHodehou — Wed, 02 Aug 2023 14:55:26 +0000

As a QA Engineer, one of the common tasks is software testing that relies on various configuration settings. These settings can include URLs, database connection strings, authentication credentials, and more. These configuration settings can be stored in various file formats, such as .ini, .csv, .json, etc., and can be read using different libraries in Python.

The challenge is that these configuration settings can change over time, and it can be tedious and error-prone to hard-code these values directly into the code. For example, if the URL of the service changes, all instances of that URL would need to be updated in the codebase.

Furthermore, if there are multiple environments (such as development, testing, and production), these configuration settings may differ between them. For instance, a development database may use a different connection string than a production database. These differences can lead to bugs and errors that are difficult to detect and resolve.

Python is one of the most popular programming languages in the world, especially in the automation field. According to the statistics, 824,793 are Python customers. Due to its simple and easy-to-learn syntax, it has become the go-to language for many developers. This popularity has led to the development of a vast array of modules and libraries that make Python an excellent choice for automation tasks.

This smoke testing tutorial covers what smoke testing is, its importance, benefits, and how to perform it with real-time examples.

Source- Trends.builtwith

One such module is the Python ConfigParser module, which allows developers to read, modify, and write configuration files in a standardized way. The Python ConfigParser module supports various configuration file formats, including INI-style files, which are commonly used in many applications.

By using Python ConfigParser, developers can store configuration settings separately in configuration files, making it easy to manage settings for different environments. This separation makes the code modular, maintainable, and easier to change. Additionally, Python ConfigParser provides a simple and consistent API for working with configuration files, making it easy to read and modify configuration settings from within the code.

In this Selenium Python testing tutorial, let’s explore the usage of Python ConfigParser to read and write configuration parameters from/into an INI file and a practical example where we automate a website login feature. Throughout the tutorial, let us leverage the unit testing framework and the Selenium library and demonstrate the power of Python ConfigParser in managing login credentials in a separate configuration file. Additionally, it showcases the flexibility of Python ConfigParser in handling multiple browsers and its usefulness in cloud testing scenarios.

With this approach, we can easily update our configuration settings without changing our code, making it more modular and maintainable.

A complete Manual testing tutorial covering all aspects of Manual testing, including strategies and best practices.

What is Python ConfigParser?

ConfigParser is a Python standard library module that allows parsing configuration files in INI format. INI stands for initialization, a simple and common file format used to store configuration data, such as application settings, database credentials, or API keys.

Here’s an example of how an INI-style configuration file looks.

[Release1]
url = http://api.release1.com
port = 8080
timeout = 10
debug = false


[Release2]
url = http://api.release2.com
port = 8081
timeout = 20
debug = true

In this example, there are two sections: [Release1] and [Release2]. Each section defines the configuration settings for a specific release. The [Release1] section contains a URL, port, timeout, and debug flag for Release 1, while the [Release2] section contains the same configuration settings for Release 2 with different values.

Using separate values for each release allows for easier management of configurations for different environments. For instance, if we need to change the URL or port for one of the releases, we can modify the corresponding section in the configuration file without affecting the other releases.

The Python ConfigParser module provides a way to read and write configuration files using a hierarchical structure of sections and options. A name in square brackets identifies sections, and options are defined as key-value pairs within each section.

The module provides a convenient and robust interface for parsing configuration files, handling errors and exceptions, and interpolating values from other sections or environment variables.

Let’s cover the basics of working with configuration files using the Python ConfigParser.

A comprehensive User Acceptance Testing (UAT) tutorial that covers what User Acceptance Testing is, its importance, benefits, and how to perform it with real-time examples.

Installing ConfigParser

ConfigParser is a built-in module in Python, so there is no need to install it separately. However, we will need to import it before we can use it in our code with the below command.

import configparser

Creating a Configuration File

To create a new configuration file, we can use the ConfigParser() constructor to create a new instance of the ConfigParser class. We can then use the write() method to write the configuration to a file.

import configparser


config = configparser.ConfigParser()
config['Section 1'] = {'key1': 'value1', 'key2': 'value2'}
config['Section 2'] = {}
config['Section 2']['key3'] = 'value3'
config['Section 2']['key4'] = 'value4'


with open(test_config.ini, 'w') as configfile:
   config.write(configfile)

This will create a new configuration file called test_config.ini in the current directory with the following content:

[Section 1]
key1 = value1
key2 = value2


[Section 2]
key3 = value3
key4 = value4

Reading a Configuration File

To read a configuration file, we can use the read() method of the Python ConfigParser object. This method takes the filename of the configuration file as its argument.

import configparser


config = configparser.ConfigParser()
config.read(test_config.ini')


print(config.sections())
# Output: ['Section 1', 'Section 2']


print(config['Section 1']['key1'])
# Output: 'value1'


print(config['Section 2']['key3'])
# Output: 'value3'

Deleting a Section or Key

To delete a section or key in a configuration file, we can use the remove_section() and remove_option() methods, respectively.

import configparser


config = configparser.ConfigParser()
config.read(test_config.ini')


config.remove_section('Section 2')
config.remove_option('Section 1', 'key1')


with open(test_config.ini', 'w') as configfile:
   config.write(configfile)

This will remove Section 2 and the key1 from Section 1 of the test_config.ini file.

Advantages of using ConfigParser

While we have established the key benefits that ConfigParser offers to developers, we can summarize them for your configuration management needs:

Simple to use: Python ConfigParser is a user-friendly module that makes it easy to handle configurations in a test automation project.
Supports multiple configuration file formats: It supports multiple configuration file formats like .ini, .conf, and .cfg files.
Allows the use of sections and keys: Python ConfigParser allows the use of sections and keys to organize configuration data, making it easy to read and update the configuration files.
**Flexible: **ConfigParser is flexible and allows developers to choose the data types for values in configuration files.
Supports interpolation: It supports interpolation, which is the ability to use values from one section in another section.
Python standard library: Python ConfigParser is readily available and does not require additional installation or setup.
Cross-platform: ConfigParser is cross-platform and can be used on any operating system that supports Python. This makes it a versatile tool for automation tasks that need to run in different environments.
Dynamic configuration support: Python ConfigParser allows us to define different key-value pairs and sections for different releases of the application. This makes it easy to manage and deploy different configurations across different environments, such as development, testing, and production.

In this Ad hoc testing tutorial, let’s deep dive into what Ad hoc testing is, its advantages, disadvantages, types, characteristics, and their best practices.

Write your first tests using Python ConfigParser

Using ConfigParser is one way to write tests for configuration files. It is a module that allows you to read and write configuration files using a simple syntax. Let’s get started with writing tests.

Step 1: Check if Python is installed

To begin, ensure the below to get Python installed on your machine.

Open a terminal.
Type the following command and press enter:
If Python is not installed or the version displayed is not the desired version, proceed to install it.

Step 2: Install Python (if necessary)

To install Python on macOS using Homebrew, follow the below steps.

Type brew install python on the terminal.
Once the installation is completed, verify the installation again using the command python --version. This time, the installed Python version should be displayed.

Step 3: Install Selenium

Follow the below pointers to install Selenium using pip:

Open a terminal on your macOS.
Type the following command and press Enter.
If you are using Python 3, use pip3 instead of pip:

Getting started with ConfigParser

In this section of the Python ConfigParser blog, we will look at the following test case for a login feature:

Use Case 1: Storing URL and Login Credentials

Let’s explore how to leverage ConfigParser to store URL and login credentials securely.

Go to https://ecommerce-playground.lambdatest.io/index.php?route=account/login
Enter your email in the E-Mail Address field.
Enter your password in the Password field.
Click on the Login button to connect.

This is what the structure of our project should look like.

config folder: Contains the test_config.ini file, which stores the configuration settings.
pages folder: Contains the login_page.py file, which contains the Page Object Model (POM) for the login page.
tests folder: Contains the test files.
utils folder: Contains the config_reader.py file, which contains a function to read the configuration settings from the test_config.ini file.

File: test_config.ini

The test_config.ini file stores the URL and login credentials for the website.

[WEBSITE]
url = https://ecommerce-playground.lambdatest.io/index.php?route=account/login
[LOGIN]
email = test@test.lambdatest.com
password = lambdatest_password

File: config_reader.py

The config_reader.py file contains a function to read the configuration settings from the test_config.ini file.

import configparser

def read_config(section, key):
   config = configparser.ConfigParser()
   config.read('config/test_config.ini')
   return config[section][key]

This function takes two arguments: section and key, which correspond to the section and key in the test_config.ini file. It returns the value of the specified key in its specified section.

File: login_page.py

The login_page.py file contains the Page Object Model (POM) for the login page.

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from utils.config_reader import read_config


class LoginPage:
   def __init__(self, driver):
       self.driver = driver
       self.wait = WebDriverWait(self.driver, 10)


   @property
   def email(self):
       return self.wait.until(EC.presence_of_element_located((By.ID, 'input-email')))


   @property
   def password(self):
       return self.wait.until(EC.presence_of_element_located((By.ID, 'input-password')))


   @property
   def submit_button(self):
       return self.wait.until(EC.element_to_be_clickable((By.XPATH, "//input[@value='Login']")))


   def login(self):
       self.email.send_keys(read_config('LOGIN', 'email'))
       self.password.send_keys(read_config('LOGIN', 'password'))
       self.submit_button.click()

In this Appium tutorial, learn about Appium and its benefits for mobile automation testing. Take a look at how Appium works and see how to perform Appium testing of your mobile applications.

This class defines the elements and actions for the login page. The class contains methods to interact with the page elements, such as the E-Mail input field, Password input field, and Submit button, as shown in Fig. 1, Fig. 2, and Fig. 3, respectively.

Fig. 1

Fig. 2

Fig. 3

It uses the Selenium WebDriverWait class to wait for the page elements to be present and clickable before interacting with them.

The @property decorator is used to define methods that behave like properties. In this case, the properties email, password, and submit_button are defined using the @property decorator. These properties are then used in the login() method to interact with the page elements.

The login() method uses the read_config() function from the config_reader module to read the login credentials from the test_config.ini file. It then sends the email and password values to the respective input fields using the send_keys() method and clicks the submit button using the click() method.

Run your Puppeteer testing scripts instantly on 50+ browser and OS combinations using the LambdaTest cloud.

File: test_login.py

The test_login.py file contains the test that tests the login feature using Python unittest and Selenium.

import unittest
from selenium import webdriver
from pages.login_page import LoginPage
from utils.config_reader import read_config
import time


class TestLogin(unittest.TestCase):
   def setUp(self):
       self.driver = webdriver.Firefox()
       self.driver.get(read_config('WEBSITE', 'url'))
       self.driver.maximize_window()


   def tearDown(self):
       self.driver.quit()


   def test_login(self):
       login_page = LoginPage(self.driver)
       login_page.login()
       time.sleep(5)


if __name__ == '__main__':
      unittest.main()

Here, we import the necessary modules, including the unittest module for creating tests, the Selenium WebDriver module for controlling the browser, the LoginPage class from the login_page file, and the read_config function from the config_reader file in utils for reading configuration data.

This class defines a test that uses setUp() to initialize the Firefox driver, open the website URL and maximize the window. tearDown() is used to close the driver after the test has run.

The test_login() method instantiates the LoginPage class and logs in using the login() method.

Now we can run our test using the command in our terminal.

python3 -m unittest

Test Overview

Once the tests are executed, the login instantiates the LoginPage class and logs in. Have a quick glimpse.

In this Selenium with Java tutorial, you will learn everything you need to know to kick start your journey in Selenium automation testing Java.

Use Case 2: Managing testing on different environments

QA Engineer, working on a web application with different environments for development, staging, and production, has different URLs and API keys. To perform the application testing, we need to execute tests on all three environments.

[DEV]
url = https://dev.lambdatest.com
api_key = abcdef123456


[STAGING]
url = https://staging.lambdatest.com
api_key = abcdef123456


[PROD]
url = https://lambdatest.com
api_key = abcdef123456

We use the environment name as a section header and list the key-value pairs specific to each environment under it. When we need to run tests in a specific environment, we can load the appropriate section and use the values in our test scripts.

For example, in our use case 1, if we wanted to use the URL of our website in the staging environment, we would modify our setUp method as follows.

class TestLogin(unittest.TestCase):
   def setUp(self):
       self.driver = webdriver.Firefox()
       self.driver.get(read_config(STAGING, 'url'))
       self.driver.maximize_window()

We can modify it depending on the environment in which we want to run our tests. We can also modify the setUp method to run the test in several environments using a loop.

class TestLogin(unittest.TestCase):
   def setUp(self):
      self.driver = webdriver.Firefox()
      self.driver.maximize_window()


      environments = ['TEST', 'STAGING', 'PROD']
      for env in environments:
          self.driver.get(read_config(env, 'url'))

In this modified setUp method, first initialize the driver and maximize the window.

Then, we define a list of environments in which we want to run the test.

React is a javascript-based mobile app development framework. Learn how to use Appium and Jest for react native automation testing tools for apps on iOS and Android.

We loop over each environment and call the read_config function with the current environment and the key URL to get the corresponding URL value from the Python config file. Finally, we call self.driver.get with the URL value to navigate to the corresponding page in the current environment.

This way, the test will run in each of the specified environments, and the URL value will be read from the corresponding Python config file for each environment.

Use Case 3: Browser Management through Configuration

Let’s try to get more out of the Python ConfigParser library by using it for an even more interesting use case. We will add a new configuration that will allow us to switch our tests from one browser to another or to run them in the main browsers without having to change them each time.

To add a new configuration to change the browser, we can modify the test_config.ini file to include a new section for BROWSER with a key-value pair for the browser to be used:

[WEBSITE]
url = https://ecommerce-playground.lambdatest.io/index.php?route=account/login


[LOGIN]
email = test@test.lambdatest.com
password = lambdatest_password


[BROWSER]
name = Edge

We can then modify the setUp() method in test_login.py to read the browser name from the test_config.ini file:

   def setUp(self):
       browser_name = read_config('BROWSER', 'name')
       if browser_name.lower() == 'chrome':
           self.driver = webdriver.Chrome()
       elif browser_name.lower() == 'firefox':
           self.driver = webdriver.Firefox()
       elif browser_name.lower() == 'edge':
           self.driver = webdriver.Edge()
       else:
           raise ValueError('Invalid browser name')
       self.driver.get(read_config('WEBSITE', 'url'))
       self.driver.maximize_window()

This modification allows us to specify which browser to use in the test_config.ini file and then use that value to initialize the appropriate driver in the setUp() method.

With these modifications, we can run our tests in different browsers by simply changing the value of the name key in the BROWSER section of the test_config.ini file.

Note that we can also use this approach to run the tests in multiple browsers by reading a list of browser names from the test_config.ini file and then initializing the corresponding drivers in a loop.

In this Selenium with Java tutorial, you will learn everything you need to know to kick start your journey in Selenium automation testing using java.

Test Overview

Here is a GIF that showcases how tests are executed in multiple browsers by reading a list of browser names from the test_config.ini file.

Use Case 4: Parallel Testing on LambdaTest

Digital experience platforms like LambdaTest facilitate automated Selenium testing using Python on an online browser farm of 3000+ real browsers and OS combinations, enabling developers and QA teams to carry out Python web automation at scale. The platform supports various Python testing frameworks such as pytest, Robot, and Behave, providing flexibility to the users.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

Visit our support documentation to get started with Selenium Python testing.

To run tests on LambdaTest, we need to add the LambdaTest credentials to our configuration file. We can add a new section for LAMBDATEST with keys for the username and access_key. You can find the same from the LambdaTest Automation Dashboard.

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

We also need to add the browser & OS combinations we want to run our parallel tests to our configuration file. To do this, we add a BROWSER_OS_LIST section.

[BROWSER_OS_LIST]
safari_latest_mac = {"browserName": "safari", "browser_Version": "latest", "platformName": "macOS Catalina"}
edge_latest_win10 = {"browserName": "MicrosoftEdge", "browser_Version": "latest", "platformName": "Windows 10"}

Let’s also modify our config_reader.py file by adding a new function that can take a section as an argument and return all the key-value pairs in that section as a dictionary.

def read_config_section(section):
   config = configparser.ConfigParser()
   config.read('config/test_config.ini')
   return config[section]

Now we need to modify our test_login.py file to be able to run our test in the browser and OS combinations defined in our configuration file.

Here is what the code should look like now:

import unittest
from selenium import webdriver
from pages.login_page import LoginPage
from utils.config_reader import read_config, read_config_section
import time , json
from selenium.webdriver.edge.options import Options as EdgeOptions




class TestLogin(unittest.TestCase):
   def setUp(self):
      browser_os_list = read_config_section('BROWSER_OS_LIST')
      self.drivers = []
      for browser_os in browser_os_list.values():




          lt_options = {
          "user": read_config('LAMBDATEST', 'username'),
          "accessKey": read_config('LAMBDATEST', 'access_key'),
          "build": "Python Configparser Tutorial",
          "name": "Python Configparser Tutorial",
          "platformName": json.loads(browser_os)["platformName"],
          "w3c": True,
          "browserName": json.loads(browser_os)["browserName"],
          "browserVersion": json.loads(browser_os)["browser_Version"],
          "selenium_version": "4.8.0"
          }




          browser_options = EdgeOptions()
          browser_options.set_capability('LT:Options', lt_options)

          driver = webdriver.Remote(
              command_executor="http://hub.lambdatest.com:80/wd/hub",
              options=browser_options)




          driver.get(read_config('WEBSITE', 'url'))
          driver.maximize_window()
          self.drivers.append(driver)




   def tearDown(self):
      for driver in self.drivers:
          driver.quit()




  def test_login(self):
      for driver in self.drivers:
          login_page = LoginPage(driver)
          login_page.login()
          time.sleep(10)




if __name__ == '__main__':
  unittest.main()

In this tutorial, learn what is Regression testing, its importance, types, and how to perform it.

Code Walkthrough

Step 1: We imported the read_config_section function that we had defined in the config_reader module and then imported JSON, a built-in Python library for working with JSON data.

Step 2: In the setUp method, we initialize the test environment. We start by reading the configuration section named ‘BROWSER_OS_LIST’ using the read_config_section function. This section contains a dictionary of operating systems and browsers.

We then initialize an empty list called self.drivers to store the WebDriver instances for each browser. Next, we iterate through each value (browser operating system) in the browser_os_list dictionary.

 lt_options = {
          "user": read_config('LAMBDATEST', 'username'),
          "accessKey": read_config('LAMBDATEST', 'access_key'),
          "build": "Python Configparser Tutorial",
          "name": "Python Configparser Tutorial",
          "platformName": json.loads(browser_os)["platformName"],
          "w3c": True,
          "browserName": json.loads(browser_os)["browserName"],
          "browserVersion": json.loads(browser_os)["browser_Version"],
          "selenium_version": "4.8.0"
          }

Inside the loop, we create a dictionary called lt_options. This dictionary contains the configuration options required for running tests on the LambdaTest platform. The values for “user” and “accessKey” are read from the configuration using the read_config function.

Other values such as “platformName”, “browserName”, and “browserVersion” are extracted from the browser_os variable, which is expected to be a JSON string.

Step 3:

We create an instance of EdgeOptions and assign it to the *browser_options *variable. We then set the capability named ‘LT:Options’ with the lt_options dictionary.

Next, we create a webdriver.Remote instance, which represents a remote WebDriver. The command_executor *parameter specifies the URL of the Selenium hub provided by LambdaTest, and the options parameter is set to the *browser_options we created earlier.

Step 4:

We use the get method of the driver instance to navigate to the URL of the website under test. The URL is retrieved from the configuration using the read_config function.

Then, we maximize the browser window using the maximize_window method of the driver. Finally, we add the driver instance to the self.drivers list.

Step 5:

In the tearDown() method, we have added a loop that goes through the list of WebDriver instances and calls the quit() method for each of them to close the browser window and free up system resources.

Step 6:

Finally, in our test case, we have added another for loop, which is used to iterate on the self.drivers list for each instance of webdriver, an instance of the LoginPage class is created.

def test_login(self):
      for driver in self.drivers:
          login_page = LoginPage(driver)
          login_page.login()
          time.sleep(10)

Test Overview

Attached are the screenshots where a test case loop is added to iterate on the self-driver list.

Are you eager to master Python automation testing? Embarking on a Selenium Python 101 certification program is an excellent choice to jumpstart your journey towards becoming an automation testing expert while enhancing your Python skills. By enrolling in this program, you’ll lay a strong foundation for effectively harnessing Selenium Python in your testing endeavors.

This certification program not only equips you with essential knowledge but also paves the path toward a prosperous career in the dynamic field of automation testing. Get ready to establish a solid groundwork and unlock endless possibilities in the world of Selenium Python.

Which are the most wanted automated testing tools in 2023 that have climbed the top of the ladder so far?

Conclusion

In conclusion, the Python ConfigParser module is a powerful tool that allows developers to read and write configuration files easily. It provides a simple and intuitive interface for parsing and accessing the configuration values and supports various file formats, such as .ini and .cfg.

With Python ConfigParser, developers can easily customize their applications and make them more flexible and adaptable to various scenarios. By following best practices like separating the configuration data from the application code and encrypting sensitive information, developers can ensure the security and robustness of their applications.

Overall, Python ConfigParser is a valuable tool for any developer and is a great way to streamline the process of managing application configurations. Using Python ConfigParser to read configuration settings from an external file can make automation testingmore efficient, flexible, and secure.

Frequently Asked Questions (FAQs)

What is the best way to write Python config file?

Writing a separate file with Python code is the simplest way to create configuration files. You could choose to name it databaseconfig.py. Then, to prevent unintentionally uploading it, you might add the line *config.py to your. gitignore file.

How to use config YAML file in Python?

The yaml.dump() method, which takes a Python object and a file reference as inputs, can be used to write data to the YAML file.

OKRs for QA : How Objectives and Key Results Can Help Improve Quality and Collaboration

JoliveHodehou — Wed, 03 May 2023 08:27:21 +0000

In today’s fast-paced software development environment, quality assurance (QA) teams are under immense pressure to ensure that the software products they release meet the highest quality standards.

However, many QA teams struggle to keep up with this demand, leading to a decrease in product quality and a breakdown in collaboration between teams. This is where Objectives and Key Results (OKRs) come into play. OKRs are a powerful tool that can help QA teams focus on what’s important and align their efforts with the overall goals of the organization.

By setting clear and measurable objectives, and tracking progress towards those objectives through key results, QA teams can improve their performance, increase collaboration with other teams, and ultimately deliver higher-quality software products.

In this article, we will explore the benefits of OKRs for QA teams and provide practical tips for implementing OKRs to improve quality and collaboration in your organization.

Get a head start on your CI/CD test cases with our pre-built template for automated testing. Explore this comprehensive list of test cases and scenarios.

What is an OKR and how does it work?

Key Objectives and Results (OKR) is a management approach that defines objectives and tracks the results or key outcomes of those objectives to assess progress. It is often used in companies to align teams and individuals with the organization’s goals.

The framework is designed to promote transparency, accountability, and continuous improvement by regularly reviewing progress toward objectives and adjusting as necessary.

This framework is widely used across various teams and departments, including Quality Assurance (QA) teams. Defining effective OKRs for QA teams is crucial for ensuring that the team is aligned with the overall company goals and is working towards improving the quality of the product or service being offered.

Typically, OKRs are defined over a period of time, such as a quarter or a year. However, in this article, we will focus on OKRs per sprint. This variation of the OKR framework is specifically designed for agile teams that work in sprints. It involves setting goals and measuring progress against those goals in a shorter time frame, typically a one- to four-week sprint.

Here is an overview of how OKRs per sprint works :

Sprint Planning: At the beginning of each sprint, the team sets specific high-level goals for the sprint that are aligned with the overall organizational strategy. These goals should be ambitious, achievable, and measurable within the sprint.

Define Key Results: For each objective, the team defines specific, measurable key results that will indicate progress toward the objective. The key results must be quantitative, achievable, and measurable within the sprint.

Assign responsibilities: Team members assign responsibilities for each objective and key result. This ensures that everyone knows their responsibilities and can work together to achieve the desired results.

Progress Tracking: Throughout the sprint, the team monitors progress on key objectives and outcomes. Weekly check-ins and progress reports ensure that everyone is on track and adjust the focus if necessary.

Sprint Review: At the end of the sprint, the team evaluates the results and reflects on what went well and what didn’t. This allows for future goal-setting and continuous improvement.

Discover the top 50+ essential Flutter test cases to ensure your mobile applications are bug free prior to their release. Download our comprehensive template now.

The importance of OKRs for QA teams

OKRs can be a vital tool for QA teams looking to improve their performance and deliver greater value to the organization. By setting specific and measurable objectives, QA teams can focus their efforts on the most critical areas, such as process optimization, bug detection, timing, quality, and communication.

OKRs help to promote transparency and collaboration, which is essential for QA teams working closely with product developers and other stakeholders. By measuring progress towards their objectives, QA teams can identify areas for improvement, make adjustments to their approach, and ensure that they are making a meaningful contribution to the organization’s success. Additionally, OKRs provide a framework for accountability, as each objective is assigned to a team member who is responsible for its delivery.

This accountability ensures that each member of the team is focused on achieving the goals that are most important to the organization, leading to greater alignment and improved performance.

OKRs can be a powerful tool for QA teams looking to optimize their processes, improve the quality of their work, and ensure that they are delivering value to the organization.

Setting effective OKRs for QA teams

Setting effective OKRs for QA is critical to ensuring that the team’s efforts align with the organization’s overall strategy and are focused on delivering high-quality products or services.

Defining OKRs for QA teams by sprint can help teams focus on specific goals, increasing their chances of achieving them. We will discuss best practices for defining effective OKRs for sprint QA teams.

Align with the sprint goal: The QA team’s objectives should be aligned with the sprint goal. The objectives should support the sprint’s mission and contribute to the sprint’s success.

Be specific and measurable: The objectives should be specific and measurable, with clear key results that can be tracked and evaluated. This allows the team to assess their progress towards achieving their objectives within the sprint and make adjustments as necessary.

Be challenging yet achievable: The objectives should be challenging enough to motivate the team but achievable enough to avoid demotivation due to unrealistic goals within the sprint time frame.

Involve the team in the process: Involving the team in the process of defining the objectives can increase their buy-in and commitment toward achieving the objectives per sprint. It also helps ensure that the objectives are realistic and achievable.

Learn 43 excellent salesforce test cases by reading this guide. Every significant test case will be covered in detail in this guide, along with how to set up your Salesforce testing.

Implementing OKRs for QA teams

Implementing OKRs for sprint-based QA teams is a strategic approach that can help align the team’s efforts with the organization’s overall goals and increase their chances of delivering high-quality products or services in a short time frame. However, integrating OKRs into existing QA processes and workflows can be challenging. Successful implementation of OKRs for QA teams by sprint requires starting small with a pilot project, tying the goals to sprint-specific QA metrics, aligning them with existing QA processes, communicating them to the team and stakeholders, reviewing and adjusting them at the end of each sprint, and providing the necessary resources.

To begin, it is essential to start small and pilot the approach before expanding it. This can be done by setting up OKRs for a small team or a specific project within a sprint, which allows for testing the approach and making adjustments before rolling it out to the entire QA team. In addition, linking goals to sprint-specific QA metrics, such as the number of test cases executed, the percentage of bugs identified and resolved, and the time to complete the test phase, helps track progress toward the goals and identify areas for improvement.

It is also critical to align OKRs with existing QA processes and workflows to ensure that they are seamlessly integrated and do not disrupt existing processes during the sprint. This can be accomplished by working with QA teams to identify existing processes, understand how they work within the sprint, and link goals to those processes. In addition, communication is essential to ensure that everyone is aligned with the sprint goals and values and understands how OKRs contribute to the success of the sprint. Finally, reviewing and adjusting the OKRs at the end of each sprint based on the performance achieved, as well as providing the necessary resources, such as time, tools, and training, can increase the chances of achieving the goals within the sprint timeframe.

Implementing OKR for sprint QA teams is a strategic approach that requires careful planning and execution to ensure success. Starting small, linking objectives to sprint-specific QA metrics, aligning them with existing QA processes, communicating them to the team and stakeholders, reviewing and adjusting them at the end of each sprint, and providing the necessary resources are essential steps to integrating OKRs into existing QA processes and workflows.

By following these steps, QA teams can successfully meet their sprint goals, improve the quality of their work, and contribute to the overall strategy of the organization.

Read this tutorial about ServiceNow Test cases, to know what it is, it’s benefits, types and test cases.

Examples of effective OKRs for QA teams

OKRs can be defined at both the team and individual levels, allowing each team member to contribute to the overall goals. In this section, we will provide examples of effective OKRs for sprint quality assurance teams, focusing on both team and individual goals.

Team-level examples of effective OKRs for sprint quality assurance teams include:

1. Validate all critical flows of the new payment gateway in staging

Key Result 1: Execute 100% of the payment gateway test cases in staging within sprint W1

Key Result 2: Ensure all identified bugs in the payment gateway are fixed before the end of sprint W1

2. Increase automation testing coverage for the mobile app

Key Result 1: Implement automated test scripts for all new features in the mobile app within sprint W2

Key Result 2: Achieve at least 70% test automation coverage for the mobile app by the end of sprint W2

Individual-level examples of effective OKRs for sprint quality assurance team members include:

1. Improve manual testing efficiency

Key Result 1: Reduce the time taken to execute a specific manual test suite by 50% within sprint W3

Key Result 2: Identify and implement at least one new manual testing technique to improve overall testing efficiency within sprint W3

2. Enhance exploratory testing skills

Key Result 1: Conduct at least 5 successful exploratory testing sessions within sprint W4

Key Result 2: Share at least one new exploratory testing approach with the team during the sprint W4 retrospective meeting.

By defining effective OKRs for sprint quality assurance teams, QA professionals can focus on specific goals, increase their chances of achieving them, and contribute to the overall success of the organization.

Impact of OKRs on QA

OKRs can have a significant impact on the achievement of QA goals by establishing clear objectives and measurable key results that are aligned with the overall business strategy. Using OKRs in QA offers several benefits such as prioritizing and optimizing efforts, determining which resources to allocate, and measuring progress.

Many companies have had success using OKRs to improve their QA processes. For example, Google has used OKRs to improve product quality, while LinkedIn has used OKRs to improve customer satisfaction. In all of these cases, OKRs helped align teams around common goals, prioritize efforts, and improve overall company performance.

However, it is essential to emphasize that the use of OKRs requires a carefully developed approach that is monitored and adjusted according to the company’s overall strategy and the specific needs of the organization. OKRs must be tailored to each company or team to ensure their effectiveness.

Discover the top 45 essential Vercel test cases along with its importance, types and usage for better understanding.

Measuring progress and success with OKRs

To track progress and measure success with OKRs per sprint for this objective, the first step is to break down the objective into measurable key results that can be tracked throughout the sprint. The two key results for this objective are:

Execute 100% of the payment gateway test cases in staging within sprint W1

Ensure all identified bugs in the payment gateway are fixed before the end of sprint W1

Once the key results are defined, the team can start tracking their progress towards each key result throughout the sprint. To do this, they can use a spreadsheet or other tracking tool to record the current status of each key result, any updates or notes on progress, and any changes to targets or priorities.

For the first key result, the team can track the percentage of payment gateway test cases that have been executed in staging during the sprint, and compare it to the target of 100%. This will help them to identify whether they are on track to meet their objective of validating all critical flows of the new payment gateway in staging. They can update their progress regularly and adjust their approach if needed to ensure that they stay on track to achieve this key result.

For the second key result, the team can track the number of identified bugs in the payment gateway, and the percentage of those bugs that have been fixed before the end of the sprint. They can compare this to the target of fixing all identified bugs before the end of the sprint, and adjust their approach if needed to ensure that they meet this target. They can also prioritize bug fixes based on their impact on the critical flows of the payment gateway to ensure that the most important issues are addressed first.

Throughout the sprint, it’s important to review progress toward each key result regularly (e.g. weekly or bi-weekly) to identify any areas where the team is falling behind and take action to get back on track. For example, if the team is not on track to execute 100% of the test cases in staging within the first week, they may need to adjust their testing strategy or prioritize their testing efforts differently to ensure that they meet their target.

At the end of the sprint, the team can review their progress towards each key result and determine whether they have achieved their overall objective of validating all critical flows of the new payment gateway in staging. If they have met both key results, they can consider the sprint success and move on to the next set of objectives for the next sprint. If they have not met one or both key results, they can use this information to inform their approach in the next sprint and adjust their tactics or targets as needed.

Overall, by breaking down objectives into measurable key results and tracking progress towards those key results throughout the sprint, teams can use OKRs to track progress and measure success per sprint. By regularly reviewing progress, adjusting their approach, and staying focused on their goals, teams can ensure that they make progress toward their objectives and continue to improve over time.

It’s important to note that the follow-up process for tracking progress and measuring success with OKRs per sprint can be adjusted based on the objectives and key results being tracked. There is no universal way to do this, as different objectives may require different tracking methods or tools, and different key results may have different levels of complexity and require different levels of attention.

Bonus: Tools for introducing OKRs into your QA team

Here are some tools that can help you introduce OKRs into your QA team:

Weekdone: https://weekdone.com/

This is a great tool for setting and tracking OKRs. It allows you to set goals and assign key results to individual team members. You can also monitor progress and receive weekly reports on how well your team is doing.

Google Sheets: https://www.google.com/sheets/about/

You can use Google Sheets to create a simple OKR template that your team can fill in. You can customize the template to fit your team’s specific needs and goals.

Asana: https://asana.com/

This project management tool can be used to create OKRs for your QA team. You can assign tasks and monitor progress, and Asana also offers a variety of reporting options.

Trello: https://trello.com/

This is another project management tool that can be used to create OKRs. You can use Trello’s boards and cards to create a simple, visual representation of your team’s OKRs and monitor progress in real-time.

Jira: https://www.atlassian.com/software/jira

If your team already uses Jira for bug tracking and project management, you can use it to set and track OKRs as well. Jira offers various customization options, and you can create custom fields and workflows to fit your team’s needs.

Remember, the tool you choose is not as important as the process you establish for setting and tracking your team’s OKRs. The key is to find a tool that works for your team and to establish a clear and consistent process for setting and tracking your goals.

Learn 37 excellent Wix test cases for testing Wix websites by reading this guide. Every significant test case will be covered in detail in this guide, along with how to set up your Wix website testing.

Final Thoughts

Integrating objectives and key results (OKRs) into quality assurance (QA) processes can have a significant impact on improving quality and collaboration. By setting clear objectives and measurable key results, QA teams can focus on achieving specific goals that align with the overall business strategy.

One of the key benefits of using OKRs in QA is that they help prioritize and streamline efforts. By setting key objectives and outcomes, QA teams can determine where to focus, where to allocate resources, and how to measure progress. This ensures that QA efforts are aligned with broader corporate goals and objectives.

Another benefit of using OKRs in QA is that they promote collaboration and transparency. By setting common goals and key outcomes, QA teams can work together toward a common goal and ensure that everyone is on the same page. This breaks down silos and promotes a culture of teamwork and accountability.

However, it is important to note that OKRs are not a quick fix. To be effective, OKRs must be carefully developed, monitored and adjusted over time. Quality assurance teams must also ensure that their OKRs are aligned with the overall business strategy and that they measure the right things.

In summary, integrating OKRs into QA can be an effective way to improve quality and collaboration. By setting clear goals and measurable key outcomes, QA teams can focus their efforts and ensure that they are aligned with broader business goals. However, it is important to approach OKRs with caution and ensure they are tailored to your organization’s specific needs and context.

How To Generate XML Reports In pytest?

JoliveHodehou — Thu, 13 Apr 2023 08:38:55 +0000

Many organizations have an automated test suite running in integration and continuous delivery systems but fail to effectively utilize the results generated at the end of the test. Without proper analysis and documentation, it becomes challenging to distinguish valuable information from irrelevant data.

The true benefit of automating testing lies not only in its ability to serve as documentation in the development process but also in its ability to increase test coverage, ensure the quality of the software, and help identify and fix bugs early in the development cycle.

Additionally, having clear and detailed test results can also aid in the overall development process by providing insight into areas of the code that may require further attention or optimization.

Therefore, effective test reporting is important and will ensure that all data at the end of your tests are properly collected and transformed into usable information. These test results can bring great benefits to a development team by providing insight into areas of the code that may require further attention or optimization. It also ensures that bugs are identified and fixed early in the development cycle, increasing the overall quality and efficiency of the software development process.

In this blog on generating XML reports in pytest, we will first briefly discuss pytest, a popular Python testing framework. Pytest allows for easy and efficient testing of Python code and is widely used in the development community. After discussing pytest, we will delve into the benefits of test reporting and how to generate XML reports in pytest.

In this XCUITest tutorial, learn about XCUITest framework and its benefits for mobile automation testing. Take a look at how XCUITest works and see how to use it to test your mobile applications.

The Importance of Test Reporting

When you start to run automated tests in your pipeline daily, you encounter different challenges. This may be due to some change in product behavior or flaws. The test report is a critical component for the QA team to analyze and perform their role effectively. It helps them evaluate the testing process and identify any issues that need to be addressed.

The test report is a key element of a test automation framework, as it plays an essential role in effectively analyzing test results. Having a test report helps you build more robust test automation suites. The efficiency with which your test report is implemented plays an important role in the overall success of your automation efforts.

Test reports help better document the product under development and provide valuable information for stakeholders to make decisions. This can result in faster time-to-market, improved return on investment, faster bug resolution, faster developer velocity, and increased visibility across the board.

By providing clear and detailed information about the results of automated tests, test reports can help to ensure the quality and reliability of the software while also improving the efficiency and effectiveness of the development process.

XML vs HTML in Test Reporting

Test reports are an essential part of any test automation framework, providing developers with detailed information about the results of automated tests. One popular format for test reports is XML, which stands for Extensible Markup Language. XML is a markup language used to organize and label the different parts of a document, making it easy to read and understand for both humans & machines.

Unlike HTML (Hypertext Markup Language), which is used to format and display data in a web browser, XML is designed to store and transport data. It allows for the creation of custom tags and self-describing languages, making it highly flexible and adaptable to various systems. XML also has a standard and clear structure, ensuring data integrity and exchange.

When choosing a format for test reports, it is important to consider your project’s specific needs and requirements. XML is a good choice for test reports because it is easy to read and understand and can be easily integrated into other systems.

Additionally, XML reports can include detailed information about test failures and errors, making it easier to identify and fix bugs. However, if you are looking for a more visual representation of your test results, HTML reporting may be a better choice. Ultimately, the choice of format will depend on your project’s specific needs and requirements.

Get started with this complete automation testing of Selenium tutorial. Learn what Selenium is, its architecture, advantages and more for automated cross browser testing. Read more.

What is pytest?

Although often overlooked, testing is an essential step in the Software Development Life Cycle (SDLC). Python comes with its built-in testing framework called unittest. However, some developers find writing tests in unittest to be complicated. In recent years, pytest, a third-party testing framework, has gained popularity among developers for its ease of use and flexibility.

Pytest is a Python testing framework designed to assist developers with writing better systems and releasing them with confidence. It requires less boilerplate code, making test suites more readable and easy to maintain. A simple assert statement is used, rather than the assertSomething methods of unittest, making it easier to write and understand tests.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

The binding system simplifies the setting and removal of the test state, keeping tests organized and reliable. A functional approach allows for more modular tests, and the large ecosystem of community-maintained plugins allows for the easy addition of functionality. Pytest Fixtures are also provided, which allows for shared setup and cleanup code across tests, making the tests more maintainable and efficient.

Overall, its ease of use and flexibility make pytest an excellent choice for improving the quality and reliability of code.

Test Environment Setup

This section of the blog on generating XML reports in pytest will cover the process of configuring a test environment.

Setting up pytest

Note: This section of the blog on generating XML reports in pytest is intended for readers who may not be familiar with setting up pytest. If you are already familiar with the process, feel free to skip this section.

The installation of pytest is simple. If you have cloned the repository, it is already installed, and you can skip this step. If you have not cloned the repository, follow these steps:

Make sure you have Homebrew on your machine because we will use a macOS operating system in this tutorial on generating XML reports in pytest.

Step 1

Type the following command in your terminal.

brew install pipenv

The pipenv installation should look like this.

Step 2

Creation of Pipfile in an empty directory. This file is essential for using Pipenv. It tracks your project’s dependencies if you need to reinstall them.

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
pytest = "*"
selenium = "*"

[requires]
python_version = "*"

The python_version parameter is the version of the base interpreter you specified when creating a new pipenv environment.

The packages section is where you can list the packages required for your project. “*” is for installing the latest stable versions of the packages.

When writing this blog on generating XML reports in pytest, the latest versions of pytest and Selenium are pytest 7.1.2 and 4.2.2, respectively.

Step 3

In your terminal, go to the directory and install the latest stable versions of the pytest and Selenium packages with the command:

Pipenv Install

This blog post demonstrates how to run tests using pytest and the LambdaTest Selenium Grid. However, it’s possible to perform these tests locally by installing the latest WebDriver version for the desired browser or by using WebDriverManager. In fact, WebDriverManager is also a thing of the past after the support for Selenium Manager was available in Selenium v4.6 (and above).

// Detect dark theme var iframe = document.getElementById('tweet-1603288968925044737-302'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1603288968925044737&theme=dark" }

Get started with this complete automation testing of selenium guide. Learn what Selenium is, its architecture, advantages and more for automated cross browser testing. Read more.

Now let’s add some code to demo how to find an element by index in Selenium WebDriver for Python from our Selenium-controlled browser.

How to generate test reports using pytest in XML?

Now that our project is ready let’s create our test suite. Our test suite will include three test scenarios

test_cart.py for test scenario 1.
test_cart.py for test scenario 2.
test_cart.py for test scenario 3.

This is what the structure of our project should look like:

Each of our test cases will contain test scenarios.

Test Scenario 1

Test Case 1- View cart (PASSED)

Go to “https://ecommerce-playground.lambdatest.io/“
Click on the View Cart button.

Test Case 2: Add a product to the cart (FAILED)

Go to “https://ecommerce-playground.lambdatest.io/“
Click on a product.
Add the product to the cart.

This second test case is expected to fail because of the usage of invalid locator for locating the requisite product on the page.

Test Scenario 2

Test Case 1: Login with valid credentials (PASSED)

Go to “https://ecommerce-playground.lambdatest.io/“
Click on the button My account.
Enter the email address.
Enter the password.
Click on the Login button.

Test Scenario 3

Test Case 1: Perform a search (PASSED)

Go to “https://ecommerce-playground.lambdatest.io/“
Enter the keyword “iphone” in the search field.
Click on the Search button.

Implementation

import pytest
import time
from selenium import webdriver
from selenium.webdriver.common.by import By


@pytest.mark.usefixtures('driver')
class TestCart():


 def test_view_cart(self, driver):
   driver.get("https://ecommerce-playground.lambdatest.io/")
   cart_button = driver.find_element(By.XPATH, '//*[@id="entry_217825"]/a/div[1]')
   cart_button.click()


 def test_add_to_cart(self, driver):
   driver.get("https://ecommerce-playground.lambdatest.io/")
   product = driver.find_element(By.XPATH, 'INVALID XPATH')
   product.click()


   add_to_cart_button = driver.find_element(By.XPATH, '//*[@id="entry_216842"]/button')
   time.sleep(5)

Code Walkthrough

The script contains two test methods, test_view_cart, and test_add_to_cart, which are decorated with the @pytest.mark.usefixtures(‘driver’) decorator.

This tells pytest to run the driver fixture before running these test methods.

The test_view_cart method navigates to https://ecommerce-playground.lambdatest.io/ using the driver.get() method and then locates the Cart button using the driver.find_element() method and the By class’s XPATH attribute. It then clicks on the Cart button.

The test_add_to_cart method also goes to the https://ecommerce-playground.lambdatest.io/ page, then tries to locate a product using an invalid XPATH. It should then locate the add to cart button and click it.

It also contains a time.sleep(5) statement, which pauses the execution of the script for 5 seconds before moving on to the next step.

Note: It is also interesting to note that the script uses an invalid XPATH to locate a product, so this test case will fail because the script will not find any items with this XPATH.

Test your website or web app online for iOS browser compatibility. Perform seamless cross browser testing on the latest iPhone tester Simulator. Try for free.

import pytest
import time
from selenium import webdriver
from selenium.webdriver.common.by import By


@pytest.mark.usefixtures('driver')
class TestLogin():


 def test_valid_credentials(self, driver):
   driver.get("https://ecommerce-playground.lambdatest.io/")
   account_button = driver.find_element(By.XPATH, '//*[@id="widget-navbar-217834"]/ul/li[6]/a/div/span')
   account_button.click()


   time.sleep(5)


   email_field = driver.find_element(By.NAME, "email")
   email_field.send_keys("email@email.com")


   password_field = driver.find_element(By.NAME, "password")
   password_field.send_keys("email")




   login_button = driver.find_element(By.XPATH, '//*[@id="content"]/div/div[2]/div/div/form/input[1]')
   login_button.click()

This script navigates to the https://ecommerce-playground.lambdatest.io/ page, then it finds the account button using the provided XPATH, clicks it, and waits for 5 seconds.

After that, it finds the email and password fields using their name attributes and enters the hardcoded values of email@email.com and email, respectively.

Finally, it finds the login button using the provided XPATH and clicks on it.

import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By


@pytest.mark.usefixtures('driver')
class TestSearch():


 def test_valid_search(self, driver):
   driver.get("https://ecommerce-playground.lambdatest.io/")
   search_field = driver.find_element(By.NAME, "search")
   search_field.send_keys("iphone")
   submit_button = driver.find_element(By.XPATH, '//*[@id="search"]/div[2]/button')
   submit_button.click()

The test_valid_search method navigates to the https://ecommerce-playground.lambdatest.io/ page. Then, it locates the search field using the driver.find_element() method and the By class’s NAME attribute and sends keys “iphone” to it.

After that, it locates the submit button using the find element method in Selenium and the By class’s XPATH attribute. The click method in Selenium is then used to click on the button element on the page.

Now that all our test cases are implemented let’s run our tests using LambdaTest Selenium Grid.

LambdaTest is a digital experience testing platform that allows developers and QAs to perform Python web automation on over 3000 real browsers and platform combinations. It supports various Python-based testing frameworks, including pytest, for conducting Selenium Python testing.

Visit our support documentation to get started with Selenium Python testing.

Here are steps you can follow:

Navigate to the LambdaTest website and log in if you already have an account, or create one if you don’t have one yet.

Once logged in, navigate to the automation page by clicking Automation on the left sidebar of your screen.

To use pytest with LambdaTest Grid, you need LambdaTest credentials (i.e., username and access key). To get the credentials, click the “Access Key” button on the right side of your screen.

Now let’s add a conftest.py file to the root of our project:

from os import environ

import pytest
from selenium import webdriver
from selenium.webdriver.remote.remote_connection import RemoteConnection

@pytest.fixture(scope='function')
def driver(request):
   desired_caps = {}

   browser = {
       "platform": "Windows 10",
       "browserName": "chrome",
       "version": "latest"
   }

   username = "YOUR_USERNAME"
   access_key = "YOUR_ACCESS_KEY"

   desired_caps.update(browser)
   test_name = request.node.name
   build = environ.get('BUILD', "Generate - Test Report")
   tunnel_id = environ.get('TUNNEL', False)

   selenium_endpoint = "@hub.lambdatest.com/wd/hub">http://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)
   desired_caps['build'] = build
   desired_caps['name'] = test_name
   desired_caps['video'] = True
   desired_caps['visual'] = True
   desired_caps['network'] = True
   desired_caps['console'] = True
   caps = {"LT:Options": desired_caps}

   executor = RemoteConnection(selenium_endpoint)
   browser = webdriver.Remote(
       command_executor=executor,
       desired_capabilities=caps
   )
   yield browser

   def fin():
       if request.node.rep_call.failed:
           browser.execute_script("lambda-status=failed")
       else:
           browser.execute_script("lambda-status=passed")
           browser.quit()

   request.addfinalizer(fin)

@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
   # this sets the result as a test attribute for LambdaTest reporting.
   # execute all other hooks to obtain the report object
   outcome = yield
   rep = outcome.get_result()

   # set a report attribute for each phase of a call, which can
   # be "setup", "call", "teardown"
   setattr(item, "rep_" + rep.when, rep)

Test Execution

Run your pytest tests with:

pipenv run python -m pytest

After the execution of the tests, you should have a summary in your console of the execution of your tests.

On your LambdaTest Automation Dashboard.

A complete tutorial on retesting that sheds light on its features, importance, pros and cons, and how to perform it.

Generate an XML Report in pytest

To generate an XML report in pytest, you can use the pytest-xml plugin. This plugin will generate an XML file containing the test results, which can be read by other tools for further analysis.

Here’s how you can use the pytest-xml plugin:

First, install the plugin using pip:

pipenv install pytest-xml

Next, run your pytest tests with the –junitxml flag to specify the path of the XML file where the results will be saved:

pipenv run python -m pytest -v --junitxml="path/to/report.xml"

The XML report will be generated at the specified path. You can open the file in a text editor or view it using a tool capable of reading XML files, such as a web browser.

Let’s open our result.xml file in a browser

In our test report in an XML file, we can find some information through tags.

testsuite:

This tag indicates our test suite. We can find attributes such as:

name: The name of the test suite
errors: The number of errors found after the execution of the test suite
failures: the number of test cases that failed after the test suite was executed
skipped: the number of test cases that were not executed
tests: the number of test cases that our test suite contains
time: the number of times the test suite was executed
timestamp: the time at which the report was generated

testcase:

classname: The name of the test case class
name: The name of the test case
time: The execution time of the test case

We also have in the failure tag the reason for the failure of the test case test_add_to_cart.

If you’re looking to become an expert in automation testing, enrolling in a Selenium Python 101 certification program is a great way to kick-start your journey toward becoming an automation testing expert and improving your Python skills. It will help you establish a solid groundwork for utilizing Selenium Python in testing and pave the way for a prosperous career in this domain.

Run your jest automation tests in massive parallel across multiple browser and OS combinations with LambdaTest, Read more.

Conclusion

In this Selenium pytest tutorial, we have seen the importance of a test report in a test automation project and how to generate XML reports in pytest framework. We started by configuring the test environment in Selenium using pytest and discovered the pytest-xml plugin that permitted us to generate an XML report in pytest.

We also saw the execution of the code on a Selenium cloud grid like LambdaTest.

I hope you enjoyed reading this article on how to generate XML reports in pytest?

Testing Microservices: A Quick Start Guide

JoliveHodehou — Fri, 24 Mar 2023 04:46:20 +0000

During the last few years, applications have grown to host millions of users and produce a large volume of data. People using these applications expect fast responses and 24/7 availability. For applications to be fast and available, they must respond quickly to the increased load.

One way to do this is to use a microservices architecture because, in a monolithic application, the main problem is the difficulty of scaling the application. The resulting application has a very large code base and poses maintainability, deployment, and modification problems.

Testing today’s environments is more complex than a few years ago. The transition to distributed environments such as microservices has created complexity, overhead, and friction in testing. Testing requires a lot of preparation, infrastructure building, and maintenance because many services communicate asynchronously.

In this testing microservices guide, you will learn what microservices architecture involves, how it compares to other software architecture models, and the technologies that make it possible. You’ll also learn about the challenges you’ll face when testing microservices in how best to evaluate their merits.

What is Microservices architecture?

Basically, microservice architecture is a software development method that aims to break down an application to isolate key functions, each of which is called a “service”.

These services are designed to be responsive to a specific and unique business need, for example, order management, shipping service, payments, or notifications. In addition, they are independent and modular, allowing each to be developed and deployed without affecting the others.

This type of architecture is the opposite of monolithic architecture, built as a single autonomous unit. Microservices are more and more used in companies, including the largest ones.

Which are the most wanted automation testing tools that have climbed the top of the ladder so far? Let’s take a look.

How does Microservices architecture work?

Microservice applications are composed of several small applications, each of which handles an individual application function. The services communicate with other services as necessary to perform their functions.

Today, most cloud applications that expose a REST/GraphQL interface are built using microservices.

Monolithic vs Microservices architecture

The monolithic architecture versus the microservices architecture has two major differences at a high level:

Monolithic architecture is a single, large, executable application.
Microservices is a set of loosely decoupled services to support larger application deployments.

Microservices architecture offers a different approach to software development. With cloud deployment technologies, API management, integration technologies, and microservices monitoring, microservices provide an agile and efficient way to deploy large, complex enterprise applications.

The big difference is that your monolithic application is disassembled into a set of independent services, which are developed, deployed, and maintained separately.

Perform browser testing on the most powerful test automation cloud infrastructure. Leverage LambdaTest automation testing for faster, reliable and scalable experience on cloud.

Monolithic architecture

When starting a project, it is easy to use this architecture because it is easy to develop. It is easy to test, and deployment can be done very simply. But this simple approach has a limit in terms of size and complexity. As the size of the application increases, there are many disadvantages.

The size of the application can slow down the start-up time. You have to redeploy the whole application with each update, and continuous deployment is also difficult.

As far as reliability is concerned, monolithic applications have significant problems. If one of the components has a bug, it will halt the whole application and process.

As technologies develop rapidly and new technologies are invented, these applications have a high barrier to adoption. As changes in frameworks or languages affect the whole application, they are extremely costly and time-consuming.

Microservice architecture

Microservices architecture represents a paradigm shift from monolithic architecture. Microservices decentralize software development and allow agile methodologies to be applied, which speeds up testing and deployment.

Let’s look at the benefits of microservices to help you understand what makes microservices so attractive.

Performance: Microservices allow for the development of language-independent applications. This means that teams can build applications in the language best suited to that type of application. One team may use a more suitable language to build an order management application’s backend, while another may use a different language for a payment microservice. This improves the performance of the whole system.
Independency: As each service can be built by a dedicated team, each team only has to worry about one part of the system. In a microservices architecture, teams are autonomous in building and deploying their service. This allows teams to work independently without fear that their changes will greatly impact the system’s overall state. It also fits well with the agile philosophy of continuous testing and delivery.
Reusability: Microservices allow parts of the service to be reused in other applications: if a payment functionality has already been created for one application and another need this functionality, the same microservice can be used in the latter.
Scalability: Microservices are infinitely scalable horizontally, and their lightweight nature allows each service to better adapt to incoming requests. As load is introduced into the system, additional servers can be added to balance the load.
Maintainability: Microservices are highly fault-tolerant. Even if one service fails, the inherently isolated nature of the architecture means that other services can be largely unaffected. Because individual services are relatively small, downtime can often be remedied quickly, as it is immediately clear which part of the service is causing the problem.

Run your Selenium Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

Despite the benefits, microservices architecture has certain challenges. Let’s look at the challenges associated with microservices architecture.

Complexity: While each service is simpler, the system as a whole is more complex. As a distributed system, care must be taken to select and configure all services and databases and then deploy each of these components independently. All the challenges of a distributed system must be considered.
Testing: Having many independent services can make test writing more complex, especially when there are many dependencies between services. A mock should be used for each dependent service to test a service as a unit.
Data integrity: Microservices have a distributed database architecture, which is a challenge for data integrity. Some business transactions, which require the update of several business functions in the application, need to update several databases belonging to different services. This requires eventual data consistency, which is more complex and less intuitive for developers.

Getting started with testing Microservices

The testing process of a microservice architecture is very different from the usual one. The particularity of a microservice architecture is that the software is provided by several services running on the backend.

As a result, we need a different and broader approach to testing, as it can be challenging to perform integration testing or to walk through the main flows during development.

However, we can quickly update an individual microservice and test it without affecting the others.

The microservices pyramid adds two new types of tests:

Component tests.
Contract tests.

The challenges of testing Microservices

Microservices require additional steps, such as managing multiple repositories and branches, each with its database schema.

But the testing challenges related to microservices architecture can be more profound than that.

Here are some key challenges associated with testing microservices:

Availability: Since different teams may manage their microservices, it is difficult to secure the availability of a microservice (or, worse still, to try to find a time when all microservices are available at the same time).
Fragmented and holistic testing: Microservices are designed to work alone and with other loosely coupled services. This means that developers must test each component in isolation, as well as test everything together.
Knowledge gaps: Especially with integration testing (which we’ll discuss later in this article), whoever is doing the testing will need to understand each service well to write test cases effectively.

Types of tests while testing Microservices

Now, let’s take a closer look at all the microservices testing type

Unit tests

Unit testing is a type of software testing that allows you to check the accuracy of individual modules or software components. The goal is to verify that each unit of code works correctly.

At the feature development stage, developers write unit tests independently because each developer knows and understands the workings of their code better and can perform this task better than the testers.

This allows you to quickly check whether the next code change has led to a regression, i.e., the appearance of errors in previously tested parts of the code. It also makes it easier to detect and eliminate such defects.

Contract tests

It is a test at the border of an external service, verifying that it meets the contract expected by consumer service.

Contract testing is a technique for testing an integration point by isolating each microservice and checking whether the HTTP requests and responses that the microservice transmits conform to a common understanding documented in a contract.

In this way, contract testing ensures that microservices can communicate.

Integration tests

Integration testing checks the interactions between different modules (or classes), usually belonging to the same subsystem, to ensure that they work together as intended when providing high-level functionality.

Integration tests also check that all the communication paths taken by the subsystem are correct and detect any incorrect assumptions that each module may have about how its peers are supposed to act. This type of test is considered the most critical test of the whole architecture.

Component tests

A component is a microservice or set of microservices that accomplishes a role within the larger system. Component testing allows you to independently validate and evaluate the performance of each component of a microservice application without integrating other services.

Generally, it is easier and faster to run component tests than to evaluate microservices.

Since it is difficult and slow to test microservices, you need to simulate other microservices or dependencies. You can isolate the dependencies by replacing them with test duplicates or dummy servers.

Modern teams adopt cloud-testing solutions like LambdaTest to perform component testing through browser testing.

Cross browser testing platforms like LambdaTest allow you to perform automated testing of components at scale over an online browser farm of 3000+ browsers and operating systems. LambdaTest provides your team with a cloud-based virtual machine running a real operating system. You can perform real-time component testing of your websites or web applications.

Run your Selenium online Automation Testing scripts on the LambdaTest cloud grid. Test on 3000+ desktop & mobile environments. Try it for free.

End-to-end tests

End-to-end testing builds on integration testing, which in turn builds on all the other forms of testing you have learned. As the name suggests, E2E tests the business logic as an integration test process, not in isolation, but as part of the whole system.

They should, in theory, simulate a real user of your application or at least perform the actions of a real user. These tests are usually the most difficult to write and consume the most development time.

Final Thoughts

Microservices architecture is a software architecture model in which each task of a larger application is presented as an independent application.

Microservices offer many advantages over other architectures, including easier deployments and better scalability. However, they also come with some challenges, including testing.

When it comes to testing microservices, there are advantages and disadvantages to consider. On the one hand, microservices can be tested independently, making finding and fixing bugs easier. On the other hand, microservices must be tested in concert with each other, which can be more complex and time-consuming.

Guide To Find Index Of Element In List with Python Selenium

JoliveHodehou — Thu, 29 Dec 2022 15:37:35 +0000

In an ideal world, you can test your web application in the same test environment and return the same results every time. The reality can be difficult sometimes when you have flaky tests, which may be due to the complexity of the web elements you are trying to perform an action on your test case.

However, web elements are essential when writing automated tests. To avoid this, it is important to use the right method to find the element you are trying to act on.

Finding an element using an index can help to avoid tests that produce inconsistent results. In this Selenium Python tutorial, we will discuss how to find index of element in list with Python using Selenium WebDriver.

So, let’s get started!

Automate cypress testing and perform browser automation testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

What is an index?

In Selenium, an index is a numerical position of an element within a list of elements. For example, if you have a list of elements representing links on a webpage and want to select the third link, you could use an index to specify that you want to select the element at the third position in the list.

An index is defined based on specific nodes in the node set for indexing using Selenium WebDriver. You can use the indexes to get a specific item in the list of identified locators. You can learn more about it from this blog on different locators in Selenium.

Let’s assume that if you write an XPath //input[@id=’lambda’], which gives you five matching nodes, then you would have to use the indexing concept.

For this, if the object is identified at index 1, then the XPath would be [//input[@id=’lambda’]][1].

Else, if it is identified at index 2, then it would be (//input[@id=’lambda’])[2].

**Note: Indexes start from 0.

Let’s take an example to illustrate better.

Example 1: LambdaTest Sign up page.

On the LambdaTest registration page, we have a country selection field, which is a select. When we use the XPath //*[@id=”country_code”] to find the element, it returns 215 nodes.

So we will need to use the indexes to find the specific element we want to interact with. Note that in this blog on how to find index of element in list with Python, we use XPath to find our locators. You have the choice to use other methods like CSS Selector etc.

Now let’s prepare our test environment. We will need to install pytest and Selenium.

How to set up a test environment?

In the section of this blog on how to find index of element in list with Python, we will learn how to set up a test environment. However, before that, let’s understand the pytest framework.

What is the pytest framework?

Pytest is a very popular Python test automation framework (mainly used for unit testing). This highly configurable and scalable testing framework comes with a rich set of features to help you write better code for Python tests.

Pytest is often described as a flexible framework with less boilerplate code than other testing frameworks. pytest fixtures provide context for tests by passing parameter names in test cases; its parameterization eliminates duplicate code for testing multiple sets of input and output, and its rewritten assert statements provide detailed output for failure causes.

Execute & analyse Cypress test scripts online. Deploy quality builds faster with 40+ browser versions on cypress cloud.

Installing the pytest framework

To install pytest on your machine, you first need to install Pipenv.

But make sure you have Homebrew on your machine because we will use a macOS operating system in this tutorial on how to find index of element in list with Python Selenium.

1- Type the following command in your terminal.

brew install pipenv

The pipenv installation should look like this:

2- Once you have installed it, make sure you have pipenv installed on your machine by typing in your terminal:

pipenv

The result should look like this:

There are several other alternatives to Pipenv for package management, which can also be used like pyenv, poetry, virtualenv, autoenv, etc. However, adding them is beyond the scope of this blog on how to find index of element in list with Python Selenium.

3- Creation of Pipfile in an empty directory. This file is essential for using Pipenv. It tracks your project’s dependencies if you need to reinstall them.

The python_version parameter is the version of the base interpreter you specified when creating a new pipenv environment.

The packages section is where you can list the packages required for your project. “*” is for installing the latest stable versions of the packages.

At the time of writing this blog on how to find index of element in list with Python Selenium, the latest versions of pytest and Selenium are pytest 7.1.2 and 4.2.2, respectively.

4- In your terminal, go to the directory and install the latest stable versions of the pytest and Selenium packages with the command:

Pipenv Install

In this blog on how to find index of element in list with Python Selenium, we will use the LambdaTest Selenium Grid with pytest to run our tests. But you could have done this locally by installing the latest version of WebDriver for the browser you want to use. You can also use WebDriverManager.

Here are the download links for the most commonly used browsers.

Firefox: GeckoDriver
Chrome: ChromeDriver
Opera: OperaDriver
Edge: Microsoft Edge WebDriver

Make sure you have the correct version for your browser; otherwise, it won’t work.

Now let’s add some code to the demo on how to find index of element in list with Python using Selenium WebDriver from our Selenium controlled browser.

This Cypress automation testing tutorial will help you learn the benefits of cypress automation, and how to install Cypress and execute Cypress automation testing over scores of browsers and operating systems online.

How to find index of element in list with Python Selenium?

In this section of the Python automation testing blog on how to find index of element in list with Python, we will consider the following test scenario to download files using Selenium Python:

1- Go to the Selenium Playground > Input Form.

2- Click on the Country DropDown.

3- Select a country (India).

4- Save the selected country in a country.txt file.

This is what the structure of our project should look like.

In the blog, we will create a tests folder.

In Python projects, it is conventional to create a “tests” directory under the project’s root directory to hold all the test cases.

We will create a file test_index.py in our “tests” folder, in which we will write our test case.

    import pytest
    import time
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    @pytest.mark.usefixtures('driver')
    class TestIndex():
      def test_index(self, driver):
       driver.get("https://www.lambdatest.com/selenium-playground/input-form-demo")
       driver.find_element(By.NAME, "country").click()
      country_index = 104
       dropdown = driver.find_element(By.NAME, "country")
       option = dropdown.find_element(By.XPATH, "//select[@name='country']/option[{}]".format(country_index))
       option.click()

       with open('country.txt', 'a') as f:
          f.write(" Selected country is : "+ option.text)
          f.write('\n')
       time.sleep(3)

Code Walkthrough:

    import pytest

The pytest module provides a rich set of tools for constructing and running tests. In this blog on how to find index of element in list with Python Selenium, we have used unittest, but several other Selenium Python testing frameworks can be used, like Unittest, Robot, DocTest, etc.

    import time

Python sleep() is a method of the Python time module. So, first, we must import the time module, and then we can use this method:

    time.sleep(3)

    from selenium import webdriver

This will import the Selenium packages that we will use for our project

    from selenium.webdriver.common.by import By

The selenium.webdriver module provides all the WebDriver implementations. Currently, supported WebDriver implementations are Firefox, Chrome, Microsoft Edge, IE, and Remote.

The By class is used to locate elements within a document.

    self.driver.find_element(By.NAME, "country").click()

Automation uses locators to find elements on a page. Selenium locators are simple query strings for finding elements. They return all elements that match their query.

Selenium WebDriver supports many locators: ID, Name, Class Name, CSS Selectors, XPath, Link text, Partial link text, and Tag name.

Here we used Name to find the country field and clicked on the element.

You will notice that the different countries all have the same tagName. So we will have to use the index to choose a specific country.

Indexes can also be useful in cases where the same XPath returns multiple web elements.

The index is defined based on specific nodes in the node set for indexing using Selenium WebDriver. We can also reference the specific node to the index using many indexes enclosed in []. The tag name UI element contains several child elements whose tag name is option.

Element:

//select[@name='country']/option

Now look at the Items tab; you will see that the XPath above returns 251 elements since there are 251 countries in the drop-down list.

Now let’s try to choose India from the list of countries:

Now that we know the index of the option, we save it in a variable country_index.

We then use this index to choose the country India.

We then saved the chosen country in a country.txt file.

Perform manual or automated testing web browsers on 3000+ browsers online. Deploy and scale faster with the most powerful cross browser testing tool online.

How to find index of element in list with Python Selenium on the cloud Grid?

To use LambdaTest Selenium Grid with pytest to perform Python web automation, you will need a LambdaTest account.

LambdaTest is a continuous quality cloud that lets you perform Python automation testing on a reliable & scalable online Selenium Grid infrastructure across 3000+ real browsers and operating systems online. Furthermore, you can also cut down build times by multiple folds using parallel test execution.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

Here are steps you can follow:

1- Navigate to the LambdaTest website and log in if you already have an account, or create one if you don’t have an account yet.

2- Once you are logged in, navigate to the automation page by clicking Automation on the left sidebar of your screen.

3- To use pytest with LambdaTest Grid, you need LambdaTest credentials (i.e. username and access key). To get the credentials, click the “Access Key” button on the right side of your screen.

This article explains the emulator vs simulator vs real device differences, the learning of which can help you select the right mobile testing solution for your business.

Implementation

Now, let’s add a conftest.py file to the root of our project:

    from os import environ

    import pytest
    from selenium import webdriver
    from selenium.webdriver.remote.remote_connection import RemoteConnection


    @pytest.fixture(scope='function')
    def driver(request):
       desired_caps = {}

       browser = {
           "platform": "Windows 10",
           "browserName": "chrome",
           "version": "latest"
       }

       username = "YOUR_USERNAME"
       access_key = "YOUR_ACCESS_KEY"

       desired_caps.update(browser)
       test_name = request.node.name
       build = environ.get('BUILD', "How To Find An Element By Index")
       tunnel_id = environ.get('TUNNEL', False)

       selenium_endpoint = "@hub.lambdatest.com/wd/hub">http://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)
       desired_caps['build'] = build
       desired_caps['name'] = test_name
       desired_caps['video'] = True
       desired_caps['visual'] = True
       desired_caps['network'] = True
       desired_caps['console'] = True
       caps = {"LT:Options": desired_caps}

       executor = RemoteConnection(selenium_endpoint)
       browser = webdriver.Remote(
           command_executor=executor,
           desired_capabilities=caps
       )
       yield browser

       def fin():
           # browser.execute_script("lambda-status=".format(str(not request.node.rep_call.failed if "passed" else
           # "failed").lower()))
           if request.node.rep_call.failed:
               browser.execute_script("lambda-status=failed")
           else:
               browser.execute_script("lambda-status=passed")
               browser.quit()

       request.addfinalizer(fin)


    @pytest.hookimpl(tryfirst=True, hookwrapper=True)
    def pytest_runtest_makereport(item, call):
       # this sets the result as a test attribute for LambdaTest reporting.
       # execute all other hooks to obtain the report object
       outcome = yield
       rep = outcome.get_result()

       # set a report attribute for each phase of a call, which can
       # be "setup", "call", "teardown"
       setattr(item, "rep_" + rep.when, rep)

Test execution in the cloud

With the various configurations set up in the conftest.py file, we are ready to run the tests.
Run pipenv run python -m pytest, and you should see the tests running in the terminal.

Once the tests have run successfully, log in to LambdaTest Automation Dashboard to check the status of the test execution.

You can see that the value of the selected element is India.

country.txt content is below:

   Selected country is : India

Bonus Section

Let’s try to do something much more fun. We’ll find all the countries starting with A and save them in a list_country.txt file. Let’s add a new function for this test case.

    def test_list_country(self, driver):
       driver.get("https://www.lambdatest.com/selenium-playground/input-form-demo")
       dropdown = driver.find_element(By.NAME, "country")
       country=dropdown.find_elements(By.XPATH, "//select[@name='country']/option")

       for i in range(2,len(country)):
         country=dropdown.find_elements(By.XPATH, "//select[@name='country']/option")
         country1=dropdown.find_element(By.XPATH, "//select[@name='country']/option[{}]".format(i))
         time.sleep(2)
         with open('list_country.txt', 'a') as f:
           f.write(" Selected country is : "+ country1.text)
           f.write('\n')

The contents of your list_country file should look like this: list_country.txt (github.com)

If you’re interested in becoming an automation testing expert and building your skills in Python, one way to get started is by earning a Selenium Python 101 certification. This will give you a strong foundation in using Selenium for testing and automation and can help you build a successful career in this field.

Need a great solution for safari for windows? Forget about emulators or simulators — use real online browsers. Try LambdaTest for free!

Conclusion

This concludes the tutorial on how to find index of element in list with Python Selenium. When you automate your web tests using Selenium, you may encounter elements in the DOM that have the same attributes. Indexes can help you perform different actions on a specific element.

I hope this has given you a good overview of how to find index of element in list with Python Selenium. If you have any questions or comments, please leave them in the section below.

Selenium with Python Tutorial: How to Get Current URL with Python

JoliveHodehou — Thu, 29 Dec 2022 14:12:14 +0000

If you use Selenium WebDriver, you probably know that there are many methods to perform specific actions or interact with elements on a web page. The Selenium Python module gives you the methods you need to be able to automate many tasks when working with a web browser online.

As a tester, you may need to know the URL of the page displayed by your Selenium-controlled web browser. This can be useful to keep track of the URL from which you have extracted certain data so that you can update this data in the automation test script. You may also need to know the current URL while making an assertion to check a keyword in the page title.

You can easily get the current URL of a web page when performing Python automation testing — to do that, you just need to access the **current_url **method of the Selenium WebDriver object.

In this Selenium Python tutorial, I will show you how to get current URL in Selenium Python using Pytest. If you are new to Pytest, you can go through this Selenium Pytest tutorial on getting started with Pytest.

Let’s get started.

Run Appium mobile testing of native and web apps. Improve your app quality with instant access to real devices on LambdaTest. Register now for free!

What is Pytest?

Pytest is one of the most popular Python test automation frameworks (primarily used for unit testing). It’s a highly configurable and extensible testing framework that comes with a rich set of features to help you write better code for testing in Python.

Pytest is described as a scalable framework with less boilerplate code than other testing frameworks. Pytest fixtures provide context for tests by passing parameter names in test cases; its parameterization eliminates duplicate code for testing multiple sets of input and output, and its rewritten assert statements provide detailed output for causes of failure.

How to set the test environment in Selenium using Pytest?

In this section of this article on how to get current URL in Selenium Python, we will learn to set up a test environment.

Installation of Pipenv

Before we start, we will set up a test environment. For this, please follow the steps below:

1- We will install Pipenv to manage our dependencies better. Pipenv is a dependency manager for Python projects. If you’re familiar with Node.js’ npm or Ruby’s bundler, it is similar in spirit to those tools.

The following command is to install pipenv on macOS. On the official pipenv website, you can see how to install it on other operating systems.

   brew install pipenv

2- Once the installation is complete, enter the command:

    pipenv

The result should look like this:

There are several other alternatives to Pipenv for package management, which can also be used like pyenv, poetry, virtualenv, autoenv, etc. However, adding them is beyond the scope of this blog.

3- Creation of Pipfile in an empty directory. This file is essential for using Pipenv. It’s used to track your project’s dependencies if you need to reinstall them.

    [[source]]
    name = "pypi"
    url = "https://pypi.org/simple"
    verify_ssl = true
    [packages]
    pytest = "*"
    selenium = "*"
    [requires]
    python_version = "*"

The python_version parameter is the version of the base interpreter you specified when creating a new pipenv environment.

The packages section is the place where you can list the packages required for your project.

“*” is for installing the latest stable versions of the packages. At the time of writing this blog on how to get current URL in Selenium Python, the latest versions of Pytest and Selenium are Pytest 7.1.2 and 4.2.2, respectively.

4- In your terminal, go to the directory and install the latest stable versions of the Pytest and Selenium packages with the command:

    pipenv install

5- Download the latest WebDriver for the browser you wish to use. A WebDriver is a remote control interface that enables introspection and control of user agents. It provides a platform- and language-neutral wire protocol for out-of-process programs to instruct the behavior of web browsers remotely.

The WebDriver Wire Protocol (aka “WebDriver protocol”) is an open standard that allows the software to interact with a browser as if a human was interacting with the browser.

Here are the download links for the most commonly used browsers.

Firefox: GeckoDriver
Chrome: ChromeDriver
Opera: OperaDriver
Edge: Microsoft Edge WebDriver

Make sure you have the correct version for your browser, otherwise it won’t work. However, you do not need a WebDriver, in case you are running your test on the cloud Selenium Grid.

The Selenium test configuration in the cloud is managed by a cloud-based Selenium Grid, such as LambdaTest, which will help you run Selenium tests for your web application to ensure cross browser compatibility.

Cloud-based cross browser testing platforms like LambdaTest allow you to perform automation testing on an online browser farm of over 3000+ browsers and operating systems.

Now, let’s add some code to demonstrate how to get current URL in Selenium Python from our Selenium-controlled browser.

Emulator online from LambdaTest allows you to seamlessly test your mobile applications, websites, and web apps on mobile browsers and mobile devices.

How to get current URL in Selenium Python using Pytest?

Now that our project is ready, it is time to add our first test scenario. Here I’ve created:

“test_ecommerce_playground.py” for scenario 1
“test_selenium_playground.py” for scenario 2.

This is what the structure of our project should look like:

In Python projects, it is conventional to create a “tests” directory under the project root directory to hold all the test cases. In this module, we simply add functions for our test cases.

We’ll write page object stubs for both pages and then use them to write our test case function. In our project, I’ve created a directory called pages right here.

Notice that this directory is outside of the **tests **directory.

We also need it outside because we want this pages directory to be a Python package.
Python packages are denoted by this init.py file (pronounced “dunder init”). It’s just an empty file inside a directory that says, “Hey, this is a Python package, and you can treat it as such, specifically for import statements.”

Let’s add a config.json file to our project. It should be located at the root of our project. The config.json is our configuration file. It allows us to define some settings or preference parameters that will be applied to our project.

It contains a browser, which I have set to “Firefox,” and an implicit timeout. We have hard-coded an implicit timeout of 10 seconds for all interactions. The best way for our tests to read this configuration file will be to use a pytest fixture. You will see this later in our conftest.py file

Which are the most wanted automated testing tools that have climbed the top of the ladder so far? Let’s take a look.

Scenario 1:

Step 1: Navigate to ‘https://ecommerce-playground.lambdatest.io/‘
Step 2: Search with the keyword “iPhone”.
Step 3: Display the current URL of the page in the console.
Step 4: Check if the search keyword is in the current URL of the page.
Step 5: Save the current URL of the page in a urls.txt file.

Let’s look at the code.

Implementation:

ecommerce_playground.py

    from selenium.webdriver.common.by import By
    from selenium.webdriver.common.keys import Keys
    class EcommercePlaygroundPage:
       #url
       url = 'https://ecommerce-playground.lambdatest.io/'
       #locators
       search_form = (By.NAME, "search")
       search_button = (By.CSS_SELECTOR, ".type-text")
       # Initializer
       def __init__(self, browser):
           self.browser = browser

       # Interaction methods
       def load(self):
           self.browser.get(self.url)
           self.browser.implicitly_wait(30)

       def search(self , keyword):
           search_form = self.browser.find_element(*self.search_form)
           search_form.send_keys(keyword)
           search_button = self.browser.find_element(*self.search_button)
           search_button.click()

Code Walkthrough:

   from selenium.webdriver.common.by import By
    from selenium.webdriver.common.keys import Keys

The selenium.webdriver module provides all the WebDriver implementations. Currently supported WebDriver implementations are Firefox, Chrome, Microsoft Edge, IE and Remote.

The By class is used to locate elements within a document.
The Keys class provides methods through which you can access keys like RETURN, F1, ALT, ENTER, and more. Please read through our earlier blog on handling keyboard actions in Selenium to learn more about it.

test_ecommerce_playground.py

   import pytest
    from pages.ecommerce_playground import EcommercePlaygroundPage
    keyword = "iPhone"
    def test_ecommerce_playground(browser):
       ecommerce_page = EcommercePlaygroundPage(browser)
       ecommerce_page.load()
       ecommerce_page.search(keyword)
       get_url = browser.current_url
       title = browser.title
       print("The current url is: "+str(get_url))
       assert "iPhone" in get_url
       with open('urls.txt', 'a') as f:
           f.write(title + " : "+ get_url)
           f.write('\n')

Execution Output:

Shown below is the page URL:

urls.txt content is below:

    Search - iPhone : https://ecommerce-playground.lambdatest.io/index.php?route=product%2Fsearch&search=iPhone

Through this usability testing tutorial, you will learn how usability testing is a great way to discover unexpected bugs, find what is unnecessary or unused before going any further, and have unbiased opinions from an outsider.

Scenario 2:

Step1: Navigate to ‘https://www.lambdatest.com/selenium-playground/‘.
Step 2: Click Simple Form Demo.
Step 3: Display the current URL of the page in the console.
Step 4: Save the current URL of the page to a urls.txt file.

Implementation:

FileName — selenium_playground.py

    from selenium.webdriver.common.by import By
    class SeleniumPlaygroundPage:
       #url
       url = 'https://www.lambdatest.com/selenium-playground/'
       #locators
       simple_form_demo = (By.XPATH, "//a[normalize-space()='Simple Form Demo']")
       # Initializer
       def __init__(self, browser):
           self.browser = browser
       # Interaction methods
       def load(self):
           self.browser.get(self.url)
       def simple_form(self):
           simple_form = self.browser.find_element(*self.simple_form_demo)
           simple_form.click()

test_selenium_playground.py

    import pytest
    from pages.selenium_playground import SeleniumPlaygroundPage
    def test_selenium_playground(browser):
       playground_page = SeleniumPlaygroundPage(browser)
       playground_page.load()
       playground_page.simple_form()
       # Get the current url of the page in a variable
       get_url = browser.current_url
       title = browser.title
       # Display the url in the console
       print("The current url is: "+str(get_url))
       # Save the url in a urls.txt file
       with open('urls.txt', 'a') as f:
           f.write(title + " : "+ get_url)
           f.write('\n')

Code Walkthrough:

Automation uses locators to find elements on a page. Selenium locators are simple query strings for finding elements. They will return all elements that match their query.

Selenium WebDriver supports many types of locators — ID, Name, Class Name, CSS Selectors, XPath, Link Text, Partial Link Text, and Tag Name.

Now let’s look at how to get locators for the target items we need for our test scenario.

Here I have used the Inspect Element to store the XPath of the Simple Form Demo link in a variable named simple_form_demo.

       simple_form_demo = (By.XPATH, "//a[normalize-space()='Simple Form Demo']")

We will use “find_element“, which is called directly from the WebDriver instance, which we have named browser in our code.

       simple_form = self.browser.find_element(*self.simple_form_demo)

To locate the Simple Form Demo element, we’ll need to say browser.find_element and we’ll pass in our simple_form_demo locator.

Now you may be wondering what this asterisk is? Well, the find_element method in Selenium takes two arguments — the locator type and then the query — but simple_form_demo is a tuple.

By adding this here, I can pass my tuple, my locator, into the find_element method. If it’s successful, it will return an object representing the simple_form element on the page.

       simple_form.click()

Now, we will use the calls to the element objects returned by the find_element methods. click() allows you to click on an element. Once I have this element, I can click on it to go to the page it redirects to.

      # Get the current url of the page in a variable
       get_url = browser.current_url

current_url returns the URL of the page currently loaded in the browser. We used this WebDriver Call to store the Current URL of the page in a variable called get_url.

       # Save the url in a urls.txt file
       with open('urls.txt', 'a') as f:
           f.write(title + " : "+ get_url)
           f.write('\n')

We then saved the contents of this variable in a urls.txt file.

Execution Output:

After clicking on Simple Form Demo, you are redirected to this page:

Content of urls.txt:

Selenium Grid Online | Run Selenium Test On Cloud :
https://www.lambdatest.com/selenium-playground/simple-form-demo

This smoke testing tutorial covers what smoke testing is, its importance, benefits, and how to perform it with real-time examples.

How to get current URL in Selenium Python on the cloud Grid?

Cloud Selenium Grid provides us with an option to run tests on a range of virtual browsers, browser versions, and operating systems securely over the cloud. LambdaTest is one such platform that provides a secure, scalable, and super reliable cloud-based Selenium Grid infrastructure that lets you run tests at scale.

LambdaTest is a cloud-based cross browser testing platform that allows you to run tests on an online device farm of 3000+ real devices running on real operating systems for mobile, desktop, and tablets. LambdaTest Selenium Grid also allows you to perform parallel testing.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress E2E testing, CI/CD, and more.

To use LambdaTest Selenium Grid with Pytest to perform Python web automation, you will need a LambdaTest account. Here are steps you can follow:

1- Navigate to the LambdaTest website and log in if you already have an account, or create one if you don’t have an account yet.

2- Once you are logged in, navigate to the automation page by clicking Automation on the left sidebar of your screen.

3- To use Pytest with LambdaTest Grid, you need LambdaTest credentials (i.e. username and access key). To get the credentials, click the “Access Key” button on the right side of your screen.

4- Let us now save the credentials (username and access key) to environment variables LT_USERNAME and LT_ACCESS_KEY.

We will create an .env file in which we will save our credentials.

    nano .env

Then Paste

    LT_USERNAME=YOUR_USERNAME
    LT_ACCESS_KEY=YOUR_ACCESS_KEY

An .env file should appear in your project once you save the changes.

Implementation:

You must now update your conftest.py file as follows:

    import json
    import pytest
    import selenium.webdriver
    from os import environ
    from selenium import webdriver
    from selenium.common.exceptions import WebDriverException
    from selenium.webdriver.remote.remote_connection import RemoteConnection
    @pytest.fixture
    def config(scope='session'):

     # Read the file
     with open('config.json') as config_file:
       config = json.load(config_file)
      # Assert values are acceptable
     assert config['browser'] in ['Firefox', 'Chrome', 'Headless Chrome']
     assert isinstance(config['implicit_wait'], int)
     assert config['implicit_wait'] > 0

     # Return config so it can be used
     return config
    @pytest.fixture
    def browser(config):
     # Initialize the WebDriver instance
     if config['browser'] == 'Firefox':
       b = selenium.webdriver.Firefox()
     elif config['browser'] == 'Chrome':
       b = selenium.webdriver.Chrome()
     elif config['browser'] == 'Headless Chrome':
       opts = selenium.webdriver.ChromeOptions()
       opts.add_argument('headless')
       b = selenium.webdriver.Chrome(options=opts)
     else:
       raise Exception(f'Browser "{config["browser"]}" is not supported')

     # Make its calls wait for elements to appear
     b.implicitly_wait(config['implicit_wait'])

     # Return the WebDriver instance for the setup
     yield b

     # Quit the WebDriver instance for the cleanup
     b.quit()
    @pytest.fixture(scope='function')
    def browser(request):
       desired_caps = {}
       browser = {
           'LT:Options' : {
             "user" : environ.get('LT_USERNAME', None),
             "accessKey" : environ.get('LT_ACCESS_KEY', None),
             "build" : "lamdatest_build",
             "name" : "lamdatest_demo",
             "platformName" : "Windows 11",
           },
           "browserName" : "Firefox",
           "browserVersion" : "99.0",
       }
       desired_caps.update(browser)
       test_name = request.node.name
       build = environ.get('BUILD', "Sample PY Build")
       username = browser.get('LT:Options', {}).get('user')
       access_key = browser.get('LT:Options', {}).get('accessKey')
       selenium_endpoint = "@hub.lambdatest.com/wd/hub">http://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)

       executor = RemoteConnection(selenium_endpoint, resolve_ip=False)
       browser = webdriver.Remote(
           command_executor=executor,
           desired_capabilities=desired_caps
       )
       yield browser
       def fin():
           #browser.execute_script("lambda-status=".format(str(not request.node.rep_call.failed if "passed" else "failed").lower()))
           if request.node.rep_call.failed:
               browser.execute_script("lambda-status=failed")
           else:
               browser.execute_script("lambda-status=passed")
               browser.quit()
       request.addfinalizer(fin)

    @pytest.hookimpl(tryfirst=True, hookwrapper=True)
    def pytest_runtest_makereport(item, call):
       # this sets the result as a test attribute for LambdaTest reporting.
       # execute all other hooks to obtain the report object
       outcome = yield
       rep = outcome.get_result()
       # set an report attribute for each phase of a call, which can
       # be "setup", "call", "teardown"
       setattr(item, "rep_" + rep.when, rep)

You can use the Selenium Desired Capabilities Generator from LambdaTest to automatically generate the capability class needed to run your Selenium automation test scripts on LambdaTest’s Selenium Grid. The Selenium Capabilities Generator will provide you with the complete capability class code based on your mouse-interactions from the user interface.

In our project we use Selenium 4, so this is what the declaration of the Desired Selenium Capabilities class looks like.

    desired_caps = {}
       browser = {
           'LT:Options' : {
             "user" : environ.get('LT_USERNAME', None),
             "accessKey" : environ.get('LT_ACCESS_KEY', None),
             "build" : "lamdatest_build",
             "name" : "lamdatest_demo",
             "platformName" : "Windows 11",
           },
           "browserName" : "Firefox",
           "browserVersion" : "99.0",
       }
       desired_caps.update(browser)

As we have saved our credentials in an environment file, we made this import to be able to use them in our conftest.py file

    from os import environ

Once the tests have run successfully, log in to LambdaTest Automation Dashboard to check the status of the test execution.

If you are looking to develop advanced, hands-on expertise in Selenium Python testing and take your career to the next level, you can take the Selenium Python 101 certification from LambdaTest.

Here’s a short glimpse of the Selenium Python 101 certification from LambdaTest:

In this Data driven testing tutorial, let us deep dive into what data driven testing is, its pros & cons, its types, data driven testing in an agile environment, benefits, and their best practices.

Conclusion

In this Selenium Python tutorial, we have seen how to get current URL in Selenium Python using the Pytest framework. We started by setting up the test environment in Selenium using Pytest and learned core methods to get the current URL in Selenium using Python. It is generally employed in cases where you require an intermediate URL from a redirect chain or need to do a series of navigations among different URLs. Finally, we saw the code execution on cloud Selenium Grid like LambdaTest.

I hope you enjoyed reading this article on how to get current URL in Selenium Python.

How To Download File Using Selenium Python

JoliveHodehou — Tue, 27 Dec 2022 10:13:52 +0000

Although browsers such as Firefox and Chrome have made downloading files easier, these downloads depend on users visiting a website and manually clicking a download button. This can be a problem if the user is interested in downloading multiple files.

By automating the task of downloading a file, you can save time and effort and focus on the features that matter. However, there are various ways to do that.

The combination of Python and Selenium opens up many opportunities for automating various tasks like clicking, typing, hovering, and downloading files. Using Selenium with Python can automate this process of downloading files by identifying and clicking the download button.

In this Selenium Python tutorial, I will show you how to download files with Selenium WebDriver and Python using the unittest testing framework. You could then download any type of file and save it in a specific folder.

So, let’s get started!

Try an online Selenium automation Grid to run your browser automation testing scripts. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

Test Environment Setup

You need to have the unittest framework, Selenium, and the different browser drivers on our machine. In this blog on how to download file using Selenium Python, we will consider running our tests on Chrome, Firefox, and Safari.

What is the unittest framework?

The unittest testing framework was initially inspired by JUnit and had a flavor similar to the major unit testing frameworks in other languages. This is the default Python test framework provided with the Python package and, therefore, the one most developers start their tests with. It can also be used for test automation, collection aggregation, etc.

Installing the unittest framework

To have unittest installed on our machine, we first need to install Python.

But make sure you have Homebrew on your machine because we will use a macOS operating system in this tutorial on how to download file using Selenium Python.

1- Type the following command in your terminal.

    brew install Python

The Python installation should look like this

2- Once you have installed it, make sure you have Python installed on your machine by typing in your terminal:

    Python --version

    Python3 --version

3- Next, you need to install Selenium on our machine. To do this, we will install pip using get-pip.py.

Download the script from https://bootstrap.pypa.io/get-pip.py.
Open a terminal/command prompt, cd to the folder containing the get-pip.py file, and run:

    python3 get-pip.py

Check if pip is installed by typing in your terminal

     pip3 --version

4- Once pip is installed, you can install Selenium in the same way.

   pip install selenium

or depending on your permissions:

   sudo pip install selenium

For Python3:

    sudo pip3 install selenium

5- Add browser driver. WebDriver is an open source tool for automated testing of web applications on many browsers. It provides capabilities for navigating web pages, user input, executing JavaScript, and much more.

We will run tests with Google Chrome, Mozilla Firefox, and Safari to download file using Selenium Python.

Type the following command in your terminal.

    brew cask install chromedriver

ChromeDriver will help us run our tests in Google Chrome. Without it, it is impossible to run Selenium test scripts in Google Chrome and automate any web application. This is why you need ChromeDriver to run test cases on the Google Chrome browser.

Once the installation is complete, check if ChromeDriver is installed by typing the command:

    chromeDriver -v

6- Now let’s install GeckoDriver, a web browser engine used in many applications developed by the Mozilla Foundation and the Mozilla Corporation. GeckoDriver is the link between your tests in Selenium and the Firefox browser.

    brew cask install geckodriver

Check if GeckoDriver is installed by typing the command:

    geckodriver -v

However, installation of the browser drivers is unnecessary if the tests will be executed on a cloud Selenium grid like LambdaTest.

LambdaTest is a cloud-based cross browser testing platform that provides you with an online browser farm of 3000+ browsers and operating system combinations to perform cross browser compatibility testing at scale.

You can also Subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around automated browser testing, Selenium testing, Cypress E2E testing, CI/CD, and more.

Test on Selenium testing tool Grid Cloud of 3000+ Desktop & Mobile Browsers.

Downloading file using Selenium Python to a specific folder

In this section of the Python automation testing tutorial, we will consider the following test scenario to download file using Selenium Python:

1- Go to the Selenium Playground.

2- Click on the File Download button.

3- In the Enter Data field, enter “How to download files using Selenium & Python?”

4- Click on the Generate File button.

5- Click on the Download button to download the file Lambdainfo.txt, which should contain “How to download files using Selenium & Python?”

This is what the structure of our project should look like.

In the blog on how to download file using Selenium Python, we will create three folders which are as follows: pages, tests, and utils.

Python packages are denoted by this init.py file (pronounced “dunder init”). It’s just an empty file inside a directory that says, “Hey, this is a Python package, and you can treat it as such, specifically for import statements.”

In our “utils” folder, we will create a locators.py file in which we will put our different locators.

    from selenium.webdriver.common.by import By
    class SeleniumPlaygroundPageLocators(object):
       #locators
      file_download = (By.XPATH, '//li[.="File Download"]')
       data_field = (By.XPATH, '//*[@id="textbox"]')
       generate_file = (By.ID, 'create')
       download_button = (By.XPATH, '//*[@id="link-to-download"]')

Tests use locators to find elements on a page. Locators are simple query strings for finding elements. They will return all elements that match their query.

Selenium WebDriver supports many types of locators . Some of the most commonly used Selenium locators include — IDs, Names, Class Names, CSS Selectors, XPaths, Link Text, Partial Link Text, and Tag Name.

Now let’s look at how to get locators for the target items we need for our test scenario. We have created a SeleniumPlaygroundPageLocators class in which we have created variables for each element in which we will save our selectors for later use in our code.

     file_download = (By.XPATH, '//li[.="File Download"]')

       data_field = (By.XPATH, '//*[@id="textbox"]')

      generate_file = (By.ID, 'create')

       download_button = (By.XPATH, '//*[@id="link-to-download"]')

I have also created a directory called “pages“. In “pages,” we will create a file selenium_playground_page.py in which the page objects are written. To learn more about page objects, refer to our earlier blog on Page Object Model (POM) in Selenium Python.

   from selenium.webdriver.common.keys import Keys
    from utils.locators import *
    import time
    # Page objects are written in this module.
    class Selenium_Playground_Page():

       def __init__(self, driver):
           self.locator = SeleniumPlaygroundPageLocators
           self.driver = driver

       def download(self, text):
           self.driver.find_element(*self.locator.file_download).click()
           self.driver.find_element(*self.locator.data_field).send_keys(text)
           self.driver.find_element(*self.locator.generate_file).click()
           self.driver.find_element(*self.locator.download_button).click()
           time.sleep(5)

Try running your browser automation testing scripts on an online Selenium automation testing Grid. There are over 3000 desktop and mobile environments in our cloud infrastructure. Take a free test!

Code Walkthrough:

    from selenium.webdriver.common.keys import Keys

The selenium.webdriver module provides all the WebDriver implementations. The Keys class provides methods through which you can access keys. You can refer to this blog on Selenium Keys to learn more about Keys class.

    from utils.locators import *

Here, we import all the classes **in our **locators.py file in the utils folder.

    import time

Python sleep() is a method of the Python time module. So, first, we must import the time module, and then we can use this method:

    time.sleep(5)

In Python projects, it is common practice to create a “tests” directory under the project’s root directory to hold all the test scenarios. In tests, we have two files test_download_file.py and conftest.py.

    import unittest
    from selenium import webdriver
    class Browser(unittest.TestCase):
       def setUp(self):
           PATH = "/Users/macbookair/Desktop/how_download_files_selenium_python/download" #This path must be modified according to your OS and the directory where you want to save your file
           self.driver.get("https://www.lambdatest.com/selenium-playground/")
       def tearDown(self):
           self.driver.close()
    if __name__ == '__main__':
       unittest.main()

Code Walkthrough:

    import unittest

The unittest module provides a rich set of tools for constructing and running tests. In this blog on how to download file using Selenium Python, we have used unittest, but several other Python testing frameworks can be used like PyTest, Robot, DocTest, etc.

    PATH = "/Users/macbookair/Desktop/how_download_files_selenium_python/download"

We have created a PATH variable in which we save the path we want to save the file that we will download with Selenium Python.

Later we will add some code to our conftest.py file to be able to run the tests on our different browsers.

    import unittest
    from tests.conftest import Browser
    from pages.selenium_playground_page import *
    # I am using python unittest for asserting cases.
    class TestDownloadFile(Browser):
       def test_download(self):
           page = Selenium_Playground_Page(self.driver)
           download_file = page.download("How to download files using Selenium & Python?")

Automate Cypress tests and perform browser automation cypress testing with LambdaTest. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

How to download file using Selenium Python in Chrome?

In our conftest.py file, we need to add some code. First, we will import the chromeOptions with the following import statement:

    from selenium.webdriver.chrome.options import Options

Chrome Options class is used to control the properties of Chrome Driver and is used with combining Desired Capabilities. It helps you perform various operations, such as defining the folder where you want to save a download file.

Usage to create a Chrome driver instance:

          #Google Chrome
           options = Options()
           prefs = {"download.default_directory" : PATH}
           options.add_experimental_option("prefs",prefs)
           self.driver = webdriver.Chrome(options=options)

options: This allows you to set the preferences of the Chrome browser.
download.default_directory: Allows to modify the default download directory. The default download folder will be the path defined in our PATH variable
add_experimental_option: Allows users to add these preferences to their Selenium webdriver object.

Our conftest.py file should now look like this:

    import unittest
    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options

    class Browser(unittest.TestCase):
       def setUp(self):
           PATH = "/Users/macbookair/Desktop/how_download_files_selenium_python/download"
           #Google Chrome
           options = Options()
           prefs = {"download.default_directory" : PATH}
           options.add_experimental_option("prefs",prefs)
           self.driver = webdriver.Chrome(options=options)
           self.driver.get("https://www.lambdatest.com/selenium-playground/")

       def tearDown(self):
           self.driver.close()

    if __name__ == '__main__':
       unittest.main()

Now you can run your test by typing in your terminal:

    python3 -m unittest

Your test should run as follows:

Once your test has run successfully, you should have the Lambdainfo.txt file in your download folder.

The file does contain the text “How to download files using Selenium & Python?”.

Execute & analyse cypress cloud test scripts online. Deploy quality builds faster with 40+ browser versions on cloud.

How to download file using Selenium Python in Firefox?

Now, we will need to create a Firefox profile. Here is the code you will need to add to your conftest.py file if you plan to run your tests with Mozilla Firefox.

           #Firefox
           profile = webdriver.FirefoxProfile()
           profile.set_preference("browser.download.folderList", 2)
           profile.set_preference("browser.download.manager.showWhenStarting", False)
           profile.set_preference("browser.download.dir", PATH)
           profile.set_preference("browser.helperApps.neverAsk.saveToDisk", "application/x-gzip")
           self.driver = webdriver.Firefox(firefox_profile=profile)

More explanation:

Profile: The profile object is specific to FirefoxDriver and contains all the preferences to be defined.
browser.download.folderList: Tells not to use the default Downloads directory.
browser.download.manager.showWhenStarting: Turns of showing download progress.
browser.download.dir: Sets the directory for downloads.
browser.helperApps.neverAsk.saveToDisk: Informs Firefox to automatically download the files of the chosen mime types.

        self.driver = webdriver.Firefox(firefox_profile=profile)

This line of code allows us to create a Firefox driver object with all the preferences.

Our conftest.py file should now look like this:

    import unittest
    from selenium import webdriver
    class Browser(unittest.TestCase):
       def setUp(self):
           PATH = "/Users/macbookair/Desktop/how_download_files_selenium_python/download"
           #Mozilla Firefox
           profile = webdriver.FirefoxProfile()
           profile.set_preference("browser.download.folderList", 2)
           profile.set_preference("browser.download.manager.showWhenStarting", False)
           profile.set_preference("browser.download.dir", PATH)
           profile.set_preference("browser.helperApps.neverAsk.saveToDisk", "application/x-gzip")
           self.driver = webdriver.Firefox(firefox_profile=profile)
           self.driver.get("https://www.lambdatest.com/selenium-playground/")

       def tearDown(self):
           self.driver.close()
    if __name__ == '__main__':
       unittest.main()

Now, we can rerun our tests.

How to download file using Selenium Python in Safari?

It is not necessary to download the Safari driver for Selenium WebDriver. Instead, the built-in Safari driver, safaridriver, is currently available in most Selenium client libraries. But before running web UI testing in Safari, ensure you enable remote automation in the Safari browser.

To allow remote automation in Safari, you must turn on WebDriver support:

1- To enable the Develop menu in the Safari browser, click Safari > Preferences > Advanced tab. Select the Show Develop Menu check box. The Develop menu appears in the menu bar.

2- To enable Remote Automation, click Develop > Allow Remote Automation in the menu bar.

3- Authorize safaridriver to launch the webdriver service that hosts the local web server. To permit this, run /usr/bin/safaridriver once manually and complete the authentication prompt.

4- Now, we will need to make some changes before running the tests. Firstly we will change the default download folder for Safari. You can do this in the Safari preferences in the general tab.

5- Now, we will disable the download confirmation alerts. In the website tab, in the preferences.

Now let’s add some code.

           #Safari
           self.driver = webdriver.Safari()

Our conftest.py file should now look like this:

    import unittest
    from selenium import webdriver
    class Browser(unittest.TestCase):
       def setUp(self):
           PATH = "/Users/macbookair/Desktop/how_download_files_selenium_python/download"
           #Safari
           self.driver = webdriver.Safari()       
           self.driver.get("https://www.lambdatest.com/selenium-playground/")
       def tearDown(self):
           self.driver.close()
    if __name__ == '__main__':
       unittest.main()

Everything is ready to run the tests with Safari. After running your tests, the result should be as follows

How to download file using cloud Selenium Grid?

Every project is unique, and you must optimize your application for any configuration to provide a smooth and consistent user experience on all devices, browsers, and operating systems.

In an ideal world, developers would test their apps using real devices under real conditions. However, in-house labs tend to be small and thus cannot provide users with real-world experiences. Instead, they opt to use emulators or simulators designed to mimic the real feelings of users. Although these tools are great for app testing, they cannot replace real devices. In such cases, you must opt for a real device cloud testing solution that offers real devices.

LambdaTest cloud Selenium Grid offers an online device farm with 3000+ real devices and browsers to help you get the job done.

In this Python web automation tutorial on how to download file using Selenium Python, we will use LambdaTest REST APIs (/user-files/download) to download files from LambdaTest cloud storage.

We will have to use the POST request to upload files to our LambdaTest storage and then the PUT request to download the user file from LambdaTest storage.

Before we continue, we will install requests, a Python library that will allow us to make HTTP requests in Python. It abstracts the complexity of requests behind a nice simple API, so you can focus on interacting with services and consuming data in your application.

Run the following command from the terminal:

pip3 install requests

Once requests are installed, you can use them in your project. Importing requests looks like this:

    import requests

In our file test_download_file.py, we import JSON and request packages.

    import requests
    import json

Then let’s add some code.

   class TestAPIDownloadFile():

           username = "username"
           access_Key = "access key"

           #POST_REQUEST
           url = "https://api.lambdatest.com/automation/api/v1/user-files"

           payload={}

           files=[
           ('files',('Lambdainfo.txt',open('/Users/macbookair/Downloads/Lambdainfo.txt','rb'),'text/plain'))
           ]

           headers = {
           'authority': 'api.lambdatest.com',
           'accept': 'application/json',
           }

           response = requests.request("POST", url, auth=(username, access_Key), headers=headers, data=payload, files=files)

           print(response.text)


           #PUT_REQUEST
           url = "https://api.lambdatest.com/automation/api/v1/user-files/download"


           payload = json.dumps({
           "key": "Lambdainfo.txt"
           })

           headers = {
           'accept': 'application/octet-stream',
           'Content-Type': 'application/json'
           }

           response = requests.request("PUT", url, auth=(username, access_Key), headers=headers, data=payload)
           open('/Users/macbookair/Documents/how_download_files_selenium_python/download/Lambdainfo.txt', 'wb').write(response.content)

           print(response.text)

Code Walkthrough:

In a new class TestAPIDownloadFile that we added to our file we declare two variables as follows:

    username = "username"
    access_Key = "access key"

These variables will be used for identification in our API calls before accessing the endpoint.

You need to replace the value of the username and access key using the authentication data that you can retrieve from the LambdaTest profile page.

          #POST_REQUEST
           url = "https://api.lambdatest.com/automation/api/v1/user-files"

           payload={}

           files=[     ('files',('Lambdainfo.txt',open('/Users/macbookair/Downloads/Lambdainfo.txt','rb'),'text/plain'))
           ]

           headers = {
           'authority': 'api.lambdatest.com',
           'accept': 'application/json',
           }

           response = requests.request("POST", url, auth=(username, access_Key), headers=headers, data=payload, files=files)

           print(response.text)

Then we make a POST request to upload a file from our computer to the lambda storage.

           files=[     ('files',('Lambdainfo.txt',open('/Users/macbookair/Downloads/Lambdainfo.txt','rb'),'text/plain'))
           ]

You must replace ‘Lambdainfo.txt‘ by the name of your file and ‘/Users/macbookair/Downloads/Lambdainfo.txt‘ by the path where the file is located.

   response = requests.request("POST", url, auth=(username, access_Key), headers=headers, data=payload, files=files)

In a response variable, we save the response of our request that we display afterward by doing.

      print(response.text)


           #PUT_REQUEST
           url = "https://api.lambdatest.com/automation/api/v1/user-files/download"


           payload = json.dumps({
           "key": "Lambdainfo.txt"
           })

           headers = {
           'accept': 'application/octet-stream',
           'Content-Type': 'application/json'
           }

           response = requests.request("PUT", url, auth=(username, access_Key), headers=headers, data=payload)
           open('/Users/macbookair/Documents/how_download_files_selenium_python/download/Lambdainfo.txt', 'wb').write(response.content)

           print(response.text)

Once our file has been uploaded to the lambda storage, we can now use our PUT requests to download it to the directory of our choice.

     payload = json.dumps({
           "key": "Lambdainfo.txt"
           })

Key identifies our file on the storage, so you have to replace it with the name of our file on the storage.

open('/Users/macbookair/Documents/how_download_files_selenium_python/download/Lambdainfo_API.txt', 'wb').write(response.content)

Then we save the file in the directory of our choice. You must replace the specified path with the one where you want to save the file.

Once the test is run in your console, you can see the response to your requests.

And the file that has been downloaded in the defined directory.

If you’re a Python programmer looking to make a name for yourself in the automation testing domain, then the Selenium Python 101 certification program from LambdaTest is your best bet.

Conclusion

This concludes the tutorial on how to download file using Selenium Python. When you automate your web tests using Selenium, you may need to test the complete functionality of a website or a web application. This means you will have to exercise features like downloading and uploading files, streaming video or audio, and reading/writing documents.

In this tutorial on Selenium Python testing, we saw how to download file using Selenium Python to a specific folder. Moreover, we learned to download file using Selenium Python in different browsers like Chrome, Firefox, and Safari. In the end, we looked at downloading file on a cloud Selenium Grid like LambdaTest.

I hope this has given you a good overview of how to download file using Selenium Python. If you have any questions or comments, please leave them in the section below.