Check out this detailed guide to learn about Automation Testing and discover how to create a successful Automation Testing system.
OVERVIEW
Automation testing involves using software tools to execute pre-scripted tests on a software application before it is released into production. This process helps in identifying bugs, ensuring software quality, and reducing manual testing efforts, making it a key component in continuous integration and continuous delivery pipelines.
Automation testing proves cost-effective in the long run, where manual testing struggles with repetitive tasks, such as regression testing, causing increased pressure on manual testers as software expands. Despite the initial effort, automation testing is more efficient, reducing errors, speeding up test completion, cutting costs, and improving software quality.
Testers use frameworks like Selenium, Playwright, Appium, etc., to automate test cases and accelerate execution, which is especially beneficial for repetitive tests like integration and regression testing. Faster tests yield quicker results, providing teams with frequent feedback for issue detection and functionality improvement.
In this tutorial, we will look into each aspect of test automation, starting from knowing what it is, its benefits, types of automation testing, and more.
Let’s get started.
Automation Testing refers to the use of specialized software to control the execution of tests and compare actual outcomes with predicted outcomes. It automates repetitive but necessary tasks in a formalized testing process, or performs additional testing that would be difficult to do manually, enhancing both efficiency and accuracy in software development.
Organizations aim to save time, reduce costs, and enhance overall software quality by automating repetitive and time-consuming manual testing procedures. Automation testing serves the purpose of cross-checking if a software application performs as expected.
This involves using scripted sequences executed by testing tools, with outcomes reported and results compared to previous test runs. The advantage lies in the reusability of automated test scripts, promoting efficiency and consistency.
Now that we've explored some significant advantages of automation testing, let's delve into its necessity through a practical scenario.
Imagine you're tasked with testing a new feature in your software, outlining a comprehensive test plan that includes 50 identified test cases. As you initiate the testing process, you encounter and report 10 bugs in the initial sprint. Subsequently, these bugs are addressed in subsequent sprints, necessitating the testing of updated software versions with each build. The challenge emerges: How can you guarantee that fixing one bug doesn't adversely impact previously functioning areas?
To address this concern, it becomes imperative to conduct thorough testing of the entire software or perform regression testing after each bug fix. As the software's complexity grows, or when faced with an increasing number of features to test, the manual testing approach becomes unwieldy. This is precisely where automation testing proves invaluable.
In such scenarios, the solution lies in automating the areas already tested and covered manually. By doing so, whenever a new build or bug fix is introduced, you can effortlessly execute the entire suite, thereby ensuring the overall health of your software.
Consequently, by investing less time, you can achieve enhanced coverage and quality for your software. An adept test automation strategy assumes a pivotal role in guaranteeing the integrity of an application, free from bugs.
In software testing, the significance of test automation lies in its ability to speed the testing process, making it more efficient and less open to human errors. With the capability to execute tests quickly and frequently without human intervention, automation allows for the early detection of issues and ensures a faster testing cycle. This is particularly critical when assessing software compatibility across different browsers, operating systems, and hardware configurations, a task impractical to perform manually due to various constraints like geographical limitations and budget considerations.
Let’s go deeper into this tutorial and learn about the benefits of automation testing to explore its advantages.
In this automation testing tutorial, let’s see what are the major differences between Manual and Automation Testing:
FEATURES | MANUAL TESTING | AUTOMATION TESTING |
---|---|---|
Test Execution | Done manually by the team members | Done using automation tools and scripts |
Test Efficiency | Time-consuming and less efficient | Saves time and is more efficient |
Test Accuracy & Reliability | Low, as manual tests are prone to human errors | High, as no scope of human errors |
Infrastructure Cost | Low, Return of Investment is low | Low (for the cloud-based test), Return Of Investment is high |
Usage | Suitable for Exploratory, Ad Hoc, and Usability Testing | Suitable for Regression, Load, and Performance Testing |
Coverage | Difficult to ensure greater test coverage | Easier to achieve greater test coverage |
Testing initiates early in an application's development lifecycle with the shift-left approach in agile development. Under this strategy, developers with technical expertise collaborate with testers to create automation, sharing increased testing responsibilities. This process is fundamental to software testing, using tools and scripts for test automation.
Below are the roles involved in making the test process effective.
Automated testing is strategically used in the software development lifecycle to enhance efficiency, identify defects promptly, and ensure the reliability of applications. Knowing when to implement automated testing to maximize its benefits and streamline the testing process is crucial. It is essential to consider the following factors while selecting which tests to automate:
Choosing the proper tests for automation is crucial to ensure that the effort is productive and efficient and adds the maximum value to the business. Software development teams can select the tests best suited for automation by considering these factors and developing a solid and effective strategy.
Let's delve into the essence of the test automation process and explore the steps for implementing them within your organization. It helps build a strong starting point and eliminates issues that make automation difficult. Here’s how you can perform automation testing.
To learn more about the metrics, explore this guide on software testing metrics. This resource will guide you in testing, developing, and maintaining your software quality.
By following the above pointers, you can establish a robust automation testing process that makes your testing process faster and contributes to the overall efficiency and quality of your software development lifecycle.
This section focuses on what test cases to automate and what to not. Let’s explore it in two parts: What is automated testing (automatable) and automated testing (non-automatable)? Even though you can automate tests such as smoke, sanity, and regression tests, tests requiring human expertise might need manual intervention. Here is a table demonstrating the same.
Automatable tests | Non-automatable tests |
Tests like regression tests must be run against every application build/release. | Tests you need to run only once in a lifetime. |
Tests use the same workflow but different input data for every test, like boundary and data-driven tests. | User experience tests involving human opinion. |
Tests require collecting multiple pieces of info during runtimes, such as low-level application attributes and SQL queries. | Tests that are short and need to be done soon, where writing test scripts would consume extra time. |
Tests that can be used for performance testing, like stress and load tests | Ad hoc or random testing based on domain expertise |
Tests take a long time to perform; you may have to run them apart from your working hours or on breaks | Tests with unpredictable results. If you want your automation validation to succeed, the outcomes should be predictable. |
Tests where you input large data volumes. | Tests where you need to watch to ensure that the results are right constantly. |
Tests that must run against multiple configurations — different OS and browser combinations, for example. | Tests that don't need to be performed against multiple browsers, OS, and devices. |
Tests during which images must be captured to prove that the application behaved as expected | Simple tests with no added value to your team. |
Automatable tests that carry the utmost importance to your product. | Tests that don't focus on the risk areas of your application. |
Automation testing comes in various forms, each serving specific purposes in software development. Common types include Unit Testing, which examines individual components, and Functional Testing, which assesses overall system functionality. Collectively, these methods enhance efficiency and reliability in the software testing process. Let's check all the different types of automation testing below.
Functional testing checks if the features of an application meet the software requirements, ensuring they deliver consistent results that align with what users expect for the best performance and experience. It involves testing by providing inputs and checking if the outcomes match what users expect.
This type of testing is done by developers while writing code for an application. The main goal of unit testing is to check if each part or unit of the code works correctly. It ensures you get the expected output when you give a particular input to an element of the code. Unit testing is like building the foundation for more complex features in the application.
For instance, an e-commerce website that allows customers to order personalized T-shirts. The website has various functionalities like selecting a color or the T-shirt, adding custom text, and choosing a size; during unit testing, developers test each of these functionalities individually to ensure that each function works as expected.
When different developers build modules or components separately, quality engineers must check if these parts work well together. This is where integration testing becomes crucial. Integration testing ensures a system's various modules and components function correctly when combined.
In modern software setups, microservices often interact with each other. Integration testing becomes even more critical to guarantee that these microservices communicate properly and operate as intended.
For instance, consider a banking app where users can set up a savings account, and there's a feature to transfer money from their main account to the savings account. Since these are separate modules, testers would perform integration testing to ensure the transaction process between the two functions is smooth and accurate. This ensures that all parts of the banking app work seamlessly together.
In this testing phase, the software undergoes comprehensive testing to confirm that all business and functional requirements are fulfilled. This testing is often called end-to-end testing and occurs just before user acceptance testing.
The system testing environment must closely mirror the production environment for accurate validation. Additionally, it follows the white box testing method, where testers have no involvement in the development of the system.
For example, consider a fitness app with features like setting and tracking monthly fitness goals, consolidating fitness metrics, creating personalized exercise sessions, and integrating with smartwatches. Each function is evaluated individually and collectively in system testing to ensure smooth integration.
Whenever software introduces a change or new feature, there's a risk of disrupting existing functionalities. To ensure the stability and continued performance of the software, regression testing is conducted each time alterations are made. Due to the labor-intensive nature of regression testing, it's often automated for efficiency.
For instance, let's take a widely used software application. The Chrome browser has introduced a new feature that improves bookmark management, where users can now organize bookmarks into folders and subfolders with nested structures. This new feature provides a more organized and user-friendly bookmarking experience.
Now, the development teams need to perform regression testing to ensure that this new bookmark management feature doesn't affect the core functionalities of the web browser.
When a new software build is completed, it undergoes smoke testing by Quality Assurance (QA) to ensure that only the most critical and essential functionalities produce the intended results. This phase, often called smoke testing, serves as an early-stage acceptance test, adding a verification layer to decide whether the new build can progress to the next stage or requires rework.
For instance, Imagine a team is working on a weather app, and they have just completed a new version. Before extensive testing, they perform smoke testing to check the core functionality that provides current temperature information quickly.
The QA team performs a quick check to ensure that, when a user opens the app, it correctly shows the current temperature for their location. So, if the smoke test passes, it indicates that the fundamental aspect of the weather app – offering the current temperature – is working as expected. If it fails, the team knows an issue needs immediate attention before further testing.
Like regression testing, sanity testing is done for a new software version with small bug fixes or added code. If the new build doesn't pass sanity testing, it won't proceed to more detailed testing. While regression testing looks at the entire system after changes, sanity testing focuses on specific areas affected by new code or bug fixes.
For instance, consider an e-commerce website where users cannot add a specific product to their cart even when it is in stock. After fixing this issue, sanity testing is carried out to ensure that the "add to cart" function works correctly.
Note : Enhance your testing experience and achieve greater accuracy in functionality testing. Try LambdaTest Now!
Non-functional testing evaluates a software application's performance, usability, dependability, and other non-functional characteristics. Unlike functional testing, it focuses on aspects beyond specific features. This type of testing aims to ensure the software meets non-functional criteria, such as reliability and efficiency.
Performance testing ensures a software application meets its performance goals, including response time and throughput. This type of testing reveals how various factors, such as network latency, database transaction processing, data rendering, and load balancing between servers, impact the performance of the software. Performance testing is typically conducted using tools like LoadRunner, JMeter, and Loader.
For instance, consider a popular e-commerce website set for a big sales event, expecting massive user traffic. Performance testing becomes crucial to ensure the website can handle the increased load without slowing down or crashing. Performance testing tool simulates many users accessing the website simultaneously, checking how well the site handles this increased demand. It assesses response times for actions like product searches, adding items to the cart, and completing the checkout process.
Load testing is a critical aspect of software testing that assesses the stability of an application under a specific load, typically equal to or less than the anticipated number of users. In practical terms, if a software application is designed to handle 250 users simultaneously with a target response time of three seconds, load testing is conducted by applying a load of up to 250 users or a number slightly below that. The primary objective is to confirm that the application maintains the desired response time of three seconds even when subjected to the specified user load.
For instance, imagine an online banking system expecting a maximum of 500 users accessing their accounts concurrently during peak hours. Load testing is executed by simulating this user load to validate that the system remains stable and responsive. The goal is to ensure that the online banking platform can efficiently handle up to 500 users without experiencing performance issues or delays, meeting the expected user experience criteria. This type of testing is crucial for identifying potential bottlenecks and optimizing the application's performance under realistic usage scenarios.
Stress testing is conducted to verify that a software program or system can withstand an unusually high load or demand. For instance, stress testing could involve subjecting a web application to many concurrent users attempting to log in simultaneously. This assesses the system's ability to handle stress and high traffic volumes without compromising performance or functionality, ensuring a robust user experience even during peak usage.
For instance, consider online ticket booking platforms expecting massive traffic during an event or festival. Stress testing would simulate a scenario where a significantly more significant number of users than usual try to access the platform simultaneously to ensure that the system remains responsive and functional under such intense demand.
Volume testing is used to verify that a software program or system can effectively handle a substantial volume of data. For instance, if a website is designed to accommodate traffic from 500 users, volume testing assesses whether the site can manage the specified volume without experiencing performance issues or data overload.
Let's take an example of an online database management system used by large e-commerce platforms. Volume testing will ensure that the uploading and managing an extensive dataset and transaction between records is done effortlessly, without slowing down the performance of the database system even when handling large volumes of data.
Usability testing ensures a software program or system is user-friendly and easy to navigate. For instance, in the context of an e-commerce website, usability testing could focus on determining whether users can quickly locate essential elements like the “Buy Now” button. This type of testing assesses the overall user experience, including navigation, instruction clarity, and interface intuitiveness.
For instance, consider that a mobile banking application is under usability testing, and testers evaluate how easy it is for users to perform everyday tasks such as transferring money or checking account balances. Testers check the clarity of interface and easy navigation and if the mobile application is user-friendly and satisfies its users. The goal of usability testing is to ensure that the users can clearly and effortlessly interact with the application with a positive user experience.
To execute usability testing, you must be aware of its various methods. Explore this guide on usability testing methods. This guide will provide you with different methods by which you can make your usability testing effective.
Compatibility testing ensures a software program or system is compatible with other software, operating systems, or environments. For example, during compatibility testing, a tester checks that the software functions seamlessly and without issues when interacting with various software applications and operating systems.
For instance, Compatibility testing is performed to see if the software works well on different web browsers (Chrome, Firefox, Safari) and is compatible with various operating systems (Windows, macOS, Linux) and checking how the software integrates with other tools commonly used in project management, like communication platforms or document-sharing applications.
Accountability testing is conducted to verify if a system functions as intended. It ensures that a specific function delivers the expected outcome. If the system produces the desired results, it passes the test; otherwise, it fails.
For Instance, consider an online shopping website where users can add items to their shopping cart and proceed to checkout. Accountability testing for this system involves checking if the "Add to Cart" function works correctly. If a user adds a product to the cart, the system should accurately reflect, and the item should be visible in the user's cart.
Reliability testing assumes a software system functions without errors within predefined parameters. The test involves running the system for a specific duration and under certain processes to assess its stability. The reliability test will fail if the system encounters issues under predetermined circumstances. For instance, in a web application, reliability testing ensures that all web pages and links consistently perform without errors, providing a reliable user experience.
For instance, consider a web-based email service focused on ensuring the reliability of its core functions—sending and receiving emails. High user activity is simulated in a continuous 72-hour test, including attaching files and marking emails as spam.
Specific scenarios, such as sudden spikes in user activity or temporary server outages, are introduced to evaluate the system's response. This reliability testing aims to confirm error-free email transactions and the system's capability to handle diverse user activities seamlessly. If the test uncovers issues, further investigation and improvements are undertaken to enhance the system's reliability.
This testing process protects the software program or system from unauthorized access or attacks. Organizations conduct security testing to identify vulnerabilities in the security mechanisms of their information systems.
For instance, consider an e-commerce platform that stores sensitive customer information, including personal details and payment data. Security testing for this platform would involve simulating various security threats, such as attempts to hack into the system, unauthorized access to customer accounts, or exploitation of potential vulnerabilities in the website's code.
Automation Testing is a complex process, and many phases lead to the successful automation of a software application. Automated tests execute a previously defined test case suite against a software application to validate that the software meets its functional requirements. During the software development lifecycle phase, an organization or a project team identifies and defines test cases that can be automated and then creates automated scripts to perform these test cases. This section discusses the following phases of automated testing.
Automation testing begins by assessing the project's feasibility. This involves identifying which application modules can be automated and detecting which tests are suitable for automation. Considerations include budgetary constraints, resource allocation, team size, and skills. Specific feasibility checks include
The choice of an automation testing tool is a crucial factor that significantly influences the effectiveness of the automation process. It marks a pivotal step in the testing cycle, demanding careful consideration to align with the project's requirements. With various automation tools and software options available, testing teams should focus on key factors when making this selection.
The decision-making process for selecting an automation testing tool involves a thoughtful evaluation of budget constraints, functionality requirements, compatibility with project technologies, and the level of familiarity within the testing team.
Moving forward in the test automation life cycle, the next critical phase involves determining the approach and procedures for automation testing. This phase encompasses the development of the test automation framework, emphasizing a thorough understanding of the product and awareness of the project's technologies.
During this step, testing teams establish test creation standards and procedures, make hardware, software, and network requirements decisions, and outline test data necessities. A testing schedule is also devised, and the appropriate error detection tool is selected.
Critical considerations for this test management phase include
Planning test cases can be critical sometimes, and this step takes place before the development of the product. To know how to write and plan test cases effectively, explore this guide on 21 lessons on writing effective test cases that follow the standard format.
The subsequent phase involves setting up the test environment, a crucial step in the automation testing life cycle that determines the configuration of remote or virtual machines for executing test cases. Understanding the significance of virtual machines is essential in ensuring a robust testing process.
Users access applications through diverse browsers, operating systems, and devices, each with multiple versions. Achieving cross browser compatibility is crucial to maintaining a consistent user experience. Hence, the establishment of a virtual testing environment becomes imperative. This phase requires careful planning to maximize test coverage and include various testing scenarios.
Key points to consider before setting up the test environment.
Key points to consider during setting up the test environment:
Tasks involved in the test environment setup include acquiring tool licenses, ensuring AUT (Application Under Test) access with valid credentials, and having utilities such as advanced text editors and comparison tools. Additionally, the setup includes configuring the automation framework, obtaining add-in licenses, and establishing a staging environment for testing.
This phase involves creating and implementing test scripts to assess the functionality and performance of the application under test. Here's a brief overview of key considerations and steps in this crucial testing stage.
Steps to prepare test scripts:
Let us look into the key points of the execution process of the test scripts below.
Execution process:
Evaluation and documentation:
After test execution, evaluate the outcomes, save them appropriately for future reference, and use the results to prepare comprehensive test result documentation. This documentation serves as a valuable record for assessing the success of the testing process.
After the execution of tests and the documentation of test results, the final and crucial stage in the automation testing life cycle is the analysis and reporting phase.
Conducting tests alone is insufficient; the results obtained from various testing types in the preceding phase must be thoroughly analyzed. Through this analysis, functionalities and segments potentially encountering issues are identified. These test reports serve as valuable insights for testing teams, guiding them to determine whether additional tests and procedures are necessary. The reports help teams comprehend how well the application performs under unfavorable conditions.
Analysis and reporting form the concluding steps in the automation testing life cycle. Test reports, derived from careful analysis, are then shared with all stakeholders involved in the project. This ensures that the insights gained from testing are communicated effectively, facilitating informed decision-making and further actions as needed.
These six automation testing life cycle stages significantly enhance an organization's software testing efforts. Automation testing is valuable for saving time, streamlining processes, and reducing the risk of human errors.
It's crucial to highlight that the true benefits of automation testing emerge when teams follow the specified sequence of steps outlined above. Implementing automation without proper planning can result in excess scripts that are challenging to manage and may require human intervention. This goes against the primary purpose of integrating automation into software testing.
To ensure a successful testing automation experience, testing teams must have a well-organized and thoughtful testing automation life cycle. Following the sequence of stages is essential for automation, contributing to the software testing process's overall effectiveness and success. The following section lets us learn more about the test automation testing strategy.
It's crucial to highlight that the true benefits of automation testing emerge when teams follow the specified sequence of steps outlined above. Implementing automation testing without proper planning can result in excess scripts that are challenging to manage and may require human intervention. This goes against the primary purpose of integrating automation testing into software testing.
To ensure a successful automation testing experience, testing teams must have a well-organized and thoughtful automation testing life cycle. Following the sequence of stages is essential for performing automation testing, which helps contribute to the overall effectiveness and success of the software testing process. Let us learn more about the automation testing strategy in the next section.
A test automation strategy is an integral component of effective software testing, providing a structured approach to determine what to automate, how to do it, and which technology to use.
Aligned with broader testing strategies, it outlines key focus areas such as scope, goals, testing types, tools, test environment, execution, and analysis by providing a clear plan of action, ensures faster bug detection, promotes better collaboration, and ultimately contributes to shorter time-to-market, enhancing the overall success of the software development project.
Below are the benefits of developing the test automation strategy:
A well-planned and executed strategy that emphasizes the objectives, parameters, and results is necessary to implement a successful strategy. Software development teams can establish an efficient process by following the above steps, which can enhance software quality, lower expenses, and shorten time-to-market.
As we learned from the above section, a well-planned strategy can help achieve success quickly. We must also know what frameworks will help these strategies come into play. In the following section, we will learn the types of automation testing frameworks in more detail.
Automation testing frameworks provide guidelines for automated testing processes. These frameworks define the organization and execution of test scripts, making it easier to maintain, scale, and enhance automated testing efforts. Various testing frameworks serve different project requirements and testing objectives based on various advantages in terms of reusability and maintainability.
Below are some automation testing framework types that help developers and testers choose the right framework for their project needs.
To learn more about how BDD differs from TDD in what aspects, explore this guide on TDD vs BDD: Selecting The Suitable Framework and see how these frameworks help make your automation testing easier. The guide provides detailed insights into what TDD and BDD entail and practical guidance on implementing both frameworks in your testing process.
In the following section, let's cover some of the most popular automation testing frameworks and tools based on different aspects, such as web-based, performance-based, API-based, and more.
In this section, we will look into some of the best test automation frameworks and tools to execute your tests. However, the choice of an automation tool depends on the specific testing requirements of your project.
Web-based automation testing framework allows the simulation of user interactions, ensuring thorough testing across various browsers and platforms. This approach enhances efficiency in software development by identifying issues early in the development lifecycle and supporting the delivery of reliable web applications.
Some of the web-based automation testing frameworks are mentioned below.
Selenium is a widely used open-source suite of tools that allows the creation of test scripts in multiple programming languages, offering flexibility for users proficient in Ruby, Java, Node.js, PHP, Perl, Python, JavaScript, C#, and more.
Primarily designed for browser automation, Selenium excels in cross-browser testing, ensuring consistent website performance across various browsers. It simplifies functional testing on different browsers to validate proper website functionality. Selenium seamlessly integrates with other tools and frameworks, including TestNG, JUnit, and Cucumber, enhancing its adaptability to various testing environments.
The introduction of Selenium 4 brings notable features, such as relative locators. These relative locators offer a faster method to identify elements on a web page by comparing them to the previous element, providing increased robustness when dealing with dynamic web content.
Selenium 4 also significantly improves the NetworkInterceptor, a crucial component for achieving comprehensive browser automation, presenting new possibilities for web app testing.
If you want to explore Selenium 4's features, a comprehensive video tutorial is available to guide you through its capabilities and enhancements.
Some of the features of Selenium are given below.
Cypress is an open-source end-to-end testing framework designed for web applications. Known for its user-friendly interface and robust feature set, Cypress has quickly gained popularity in the automation testing field. It is a preferred choice among developers for quickly and effectively testing applications directly within their web browsers.
Explore this tutorial on Cypress and get valuable insights with examples and best practices.
Some of the features of Cypress are given below.
Playwright, an end-to-end testing automation framework developed by Microsoft, has gained increasing popularity and is the preferred choice for automation testing. It offers a single API to automate Chromium, Firefox, and WebKit browsers. Playwright testing uses Node.js, JavaScript, and TypeScript, making it versatile and accessible to many users.
Some of the features of Playwright are given below.
Puppeteer is a test automation framework designed for direct interaction with Chrome-based browsers such as Chrome and Chromium, with additional compatibility for Firefox (Nightly Build). Its advanced capabilities and easy installation using npm or Yarn empowers users to seamlessly access and manage the DevTools Protocol.
Moreover, Puppeteer enables the creation of a testing environment that facilitates easy test updates and execution in the latest Chrome version. This ensures compatibility with the most recent JavaScript, browser features, and APIs.
Some of the features of Puppeteer are given below.
Mobile-based automation uses automated testing frameworks to assess mobile applications' functionality, performance, and user experience. It enables the creation of automated scripts to simulate interactions on mobile devices, ensuring comprehensive testing across different platforms and devices. This approach is crucial for delivering high-quality mobile applications that meet user expectations and perform reliably in diverse environments.
Some of the best mobile app testing frameworks are mentioned below.
Appium is an open-source test automation framework designed for testing native, hybrid, and mobile web applications across diverse devices and platforms. It operates based on the WebDriver protocol, a standard API widely used for automating web browsers. Appium's flexibility allows users to write tests in their preferred programming language, Java, Python, or JavaScript.
Some of the features of Appium are given below.
Watch this complete video tutorial to start mobile app testing with Appium, get valuable insights and practical knowledge, and boost your testing process.
Espresso is a mobile test automation framework specifically designed for Android applications. Developed by Google, it seamlessly integrates with the Android SDK. Espresso offers a range of features that simplify the process of writing, running, and maintaining UI tests for Android applications.
Some of the features of Espresso are given below.
XCUITest is a mobile test automation framework specifically designed for iOS applications. Developed by Apple, it is seamlessly integrated with Xcode. XCUITest comes equipped with features that simplify the process of writing, running, and maintaining UI tests for iOS applications.
Some of the features of XCUITest are given below.
Selendroid, often called Selenium for Android mobile apps, is a testing tool for native and hybrid mobile applications. It allows testers to conduct comprehensive mobile application testing on Android platforms. Like Selenium's cross-browser testing capabilities, Selendroid can execute parallel test cases across multiple devices.
Some of the features of Selendroid are given below.
Performance-based automation testing frameworks and tools focus on the testing processes related to the performance aspects of software applications. It involves creating automated scripts to simulate and evaluate the performance of an application under different conditions, such as varying user loads and network conditions. This approach ensures that software functions correctly and performs optimally, meeting the expected levels of responsiveness and scalability.
Some of the performance-based automation testing tools are mentioned below.
Apache JMeter is a robust open-source tool developed by the Apache Software Foundation. Widely used for load and performance testing, it proves effective for evaluating the performance of web applications, APIs, databases, and server-based systems. JMeter facilitates the simulation of diverse scenarios and the generation of loads to assess system performance under varying conditions.
JMeter's primary objective is to assess a system's capability to manage a designated workload, measure response times and throughput, and pinpoint potential performance bottlenecks.
Some of the features of Apache JMeter are given below.
LoadRunner plays a crucial role in simulating and evaluating the performance of both web and mobile applications across diverse load conditions. Supporting multiple protocols, LoadRunner is equipped with advanced scripting capabilities and provides extensive reporting and analysis features. Its primary application lies in performance testing, which is invaluable for assessing applications' performance under different loads and stress levels.
Some of the features of LoadRunner are given below.
k6 is an open-source performance testing tool created explicitly for load-testing web applications and APIs. Engineered with a developer-centric approach, it enables developers and testers to assess the performance and scalability of their systems across diverse load conditions.
It is known for its user-friendly design, adaptability, and seamless integration with the contemporary development ecosystem. k6 empowers teams to measure and optimize system performance efficiently.
Some of the features of k6 are given below.
To explore k6 and its features, as well as to learn how to write your first k6 testing script, refer to the k6 testing tutorial for step-by-step guidance and instructions and get detailed insights on k6.
BlazeMeter is a cloud-based load-testing platform designed to facilitate application performance and load testing. Owned by Broadcom (formerly CA Technologies), it encourages developers and testers to create and execute performance tests seamlessly. BlazeMeter supports utilizing popular open-source testing tools such as Apache JMeter, Gatling, and Selenium WebDriver, providing a comprehensive solution for testing and optimizing application performance.
Some of the features of BlazeMeter are given below.
API-based automation testing frameworks and tools streamline software testing by automating processes related to application programming interfaces (APIs), ensuring robustness and reliability in software development. It enables efficient validation of API functionality, early issue identification, and faster delivery of high-quality applications. This approach is integral to modern software development, optimizing testing practices for enhanced efficiency and stability.
Some of the API-based automation testing tools are mentioned below.
It is a highly utilized automation testing tool for APIs. Its versatility enables users to create various tests, from functional and integration to regression tests, and smoothly execute them in CI/CD pipelines through the command line.
Some of the features of Postman are given below.
SoapUI is an open-source functional testing tool developed by Smartbear, recognized as a leader in Gartner Magic Quadrant for Software Test Automation. It is a comprehensive API Test Automation Framework for Representational State Transfers (REST) and Service-Oriented Architectures (SOAP).
While SoapUI is not designed for web or mobile app testing, it stands out as a preferred API and services testing tool. Notably, it operates as a headless functional application specializing in API testing.
Some of the features of SoapUI are given below.
REST Assured is a widely used testing framework designed for RESTful APIs and is particularly suitable for developers comfortable with Java. It streamlines API testing by offering a user-friendly syntax, enabling testers to construct requests without starting from code basics.
Some of the features of REST Assured are given below.
Apigee serves as a versatile cross-cloud API testing tool, empowering users to assess and test API performance and facilitating the development and support of APIs. Additionally, Apigee offers compliance with PCI, HIPAA, SOC2, and PII standards for applications. Notably, it has consistently been recognized as a leader in the 2019 Gartner Magic Quadrant for Full Lifecycle API Management four consecutive times.
This tool is designed for digital businesses, specifically for service data-rich, mobile-driven APIs and applications. Starting from version 4.19.01 in 2019, Apigee offers enhanced API management flexibility, including features such as Open API 3.0 support, TLS security, self-healing with apogee-monit, and improvements in virtual host management. The latest version includes minor bug fixes and security enhancements, maintaining its reputation as a feature-rich and well-regarded tool among users.
Some of the features of Apigee are given below.
Automating tests involves using software tools to execute predefined test cases on a software application, replacing manual testing efforts. This process is integral to modern software development, enhancing efficiency and accuracy, and is a key component in Agile and DevOps practices for continuous delivery.
Since many organizations have moved on to Agile and DevOps methodologies for software project delivery, people have started demanding high-end efficiency and speed. Hence, automated tests have become unavoidable for modern organizations. As per GMInsights, the overall growth would be between 7%-12% CAGR until the end of 2025.
DevOps streamlines software development workflows, accelerating processes like build, test, configuration, deployment, and release. Automated testing is integral to continuous integration and delivery (CI/CD), enhancing efficiency and enabling frequent software releases.
Quality assurance engineers focus on automated integration and end-to-end tests, while developers conduct unit tests. Early execution of these tests in the DevOps CI/CD pipeline ensures component functionality. Product managers contribute to functional testing for an optimal user experience, utilizing methods like the black-box approach. This collaborative approach enhances the overall efficiency of the DevOps process.
By automating repetitive testing processes, development teams can achieve faster feedback, improved accuracy, and increased test coverage. This ensures a more robust and streamlined software development lifecycle. Let's delve into the key benefits of automated testing and how it positively impacts the development and delivery of software products.
Myth: Test automation replaces manual testing ultimately.
Reality: Test automation enhances efficiency but cannot entirely replace manual testing, especially in exploratory and user-experience testing scenarios.
Myth: Automating tests is quick and effortless.
Reality: Test automation requires time, effort, and resources for effective implementation. Continuous optimization and improvement are necessary to keep up with changing software requirements.
Myth: No need for human testers with automation.
Reality: Human testers are essential for creating, maintaining, and evaluating automated tests. Automation complements human testing but cannot replace human testers' unique insights and context.
These myths highlight common misconceptions about test automation's scope, effort, and role in the software testing process.
Manual testing is a traditional approach that involves human testers carefully executing test cases to identify defects, ensure functionality, and assess overall system performance. While manual testing provides a hands-on and intuitive evaluation, it comes with its own set of challenges.
It encounters challenges mainly tasked with testing extensive applications across various browsers. The challenges include:
Automation testing with Selenium emerges as a practical solution to address manual testing challenges. Specifically designed for cross-browser testing, it enables parallel testing and more. Selenium, with its local Selenium Grid, allows automated WebDriver tests in remote browsers. This ensures thorough testing at the UI layer, addressing the limitations of manual testing.
For local automated browser testing, the Selenium Grid offers a straightforward solution. This allows running tests against various browser versions and operating systems. Download and install the appropriate browser driver for the desired test browser.
However, for more scalable and extensive browser compatibility testing across various combinations of browsers, devices, and operating systems, automation testing in a cloud-based solution is recommended with one such platform as LambdaTest.
LambdaTest is an AI-powered test orchestration and execution platform that lets you run manual and automated tests at scale with over 3000+ real devices, browsers, and OS combinations.
On LambdaTest, Selenium tests utilize the grid's capabilities to execute tests simultaneously across multiple combinations, enhancing automation testing coverage and providing greater confidence in the product.
To learn more about automation testing with LambdaTest, watch this complete video tutorial below.
LambdaTest supports a wide range of frameworks and tools integration for web testing and app test automation, such as Selenium, Cypress, Playwright, Puppeteer, Taiko, Appium, Espresso, XCUITest, etc.
It supports parallel testing, which enables you to run several tests concurrently across various browsers and devices. This can scale your test efforts and reduce the time duration needed to run automated tests.
LambdaTest lets you access a variety of browsers, operating systems, and devices without setting up and maintaining your infrastructure. This can lower your expenses and make it easier to scale your test efforts.
Some of the advantages of LambdaTest are below.
To learn more about the LambdaTest platform, follow this detailed LambdaTest documentation and demo video to get familiar with the features of LamdbaTest that can help you boost your automation testing process.
Subscribe to the LambdaTest YouTube Channel for the latest updates on tutorials around Selenium testing, Cypress testing, Playwright testing, and more.
In the following section, we will see how to test browser automation over cloud testing platforms like LambdaTest to understand its functionalities better.
In this section, let us conduct browser automation testing on LambdaTest, a platform that facilitates seamless cross-browser testing for enhanced efficiency and comprehensive test coverage. Let's get started by following the step-by-step procedure.
Step 1: Create a LambdaTest account.
Step 2: Get your Username and Access Key by going to your Profile avatar from the LambdaTest dashboard and selecting Account Settings from the list of options.
Step 3: Copy your Username and Access Key from the Password & Security tab.
Step 4: Generate Capabilities containing details like your desired browser and its various operating systems and get your configuration details on LambdaTest Capabilities Generator.
Step 5: Now that you have both the Username, Access key, and capabilities copied, all you need to do is paste it into your test script as shown below.
Note: The below shown code is just the structure to display where to add Username, Access key, and capabilities
import static org.testng.Assert.assertTrue;
import java.net.URL;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.LocalFileDetector;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class LamdaTestUploadFileRemotely {
private RemoteWebDriver driver;
@BeforeClass
public void setUp() throws Exception {
//LambdaTest Capabilities.
ChromeOptions capabilities = new ChromeOptions();
capabilities.setCapability("user","<username>");
capabilities.setCapability("accessKey","<accesskey>");
capabilities.setCapability("build", "Build 2");
capabilities.setCapability("name", "Check Uploaded Image");
capabilities.setCapability("platformName", "Windows 10");
capabilities.setCapability("browserName", "Chrome");
capabilities.setCapability("browserVersion","79.0");
driver = new RemoteWebDriver(new URL("http://hub.lambdatest.com:80/wd/hub"), capabilities);
driver.setFileDetector(new LocalFileDetector());
driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
}
@Test
public void lamdaTest() throws Exception {
// your code here
}
@AfterClass
public void tearDown() throws Exception {
driver.quit();
}
}
Note: These capabilities will differ for each programming language and testing framework you choose.
Step 6: To view your test results, whether passed or failed or if it has encountered any issues, you need to visit the LambdaTest dashboard; from the menu, click on the Automation option.
Step 7: Click on the Web Automation option from the menu and you can see the builds to get clear insights into the automation test, such as passed tests, build sessions, failed tests, timeout, errors, and more.
Understanding the test automation boundary is crucial for effective QA testing. The quality of your testing is directly tied to the strategy you use. However, there are limitations to test automation that need consideration.
Recognizing and addressing these limitations is crucial for a more effective and successful test automation strategy.
Test automation comes with its own set of challenges. Understanding and addressing these challenges is crucial for establishing a robust and effective test automation strategy. In this section, let us explore some test automation challenges and their solutions.
A major worry for teams with tight budgets is the significant upfront cost when starting with automation. The expenses involved in setting up an automation suite can deter testers from adopting automation testing. Alongside day-to-day costs, there might be additional expenses for software licenses.
Solution:
To deal with budget issues associated with automation implementation, teams can adapt to a strategic approach by prioritizing critical test cases for automation, using open-source tools like Selenium or Appium to minimize licensing costs, and focusing training efforts on practicals. Encourage collaboration within the team to share knowledge, reducing the dependency on external training resources and making automation adoption more cost-effective.
This challenge isn't just for automation teams and manual testing groups. However, it's more complex in automation because it demands extensive communication and collaboration within the team. Test automation is an investment, so getting everyone on board involves communicating objectives, providing evidence and historical data, and even proof of concept. We need clear goals to keep the entire team aligned.
Unlike manual testers, who mainly talk with developers and managers, as automation testers, we discuss plans, scope, and what to automate with various team members. We also present cost and benefit analyses, including Return on Investment (ROI), to higher management.
Without their support, the automation effort is at risk. Effectively communicating and collaborating among teams is a significant challenge, as ineffective communication can turn automation experiences into a nightmare.
Solution:
Build a communication plan by defining clear goals and maintaining regular team alignment. Encourage open discussions among various team members, including developers and managers. Present detailed cost and benefit analyses, including Return on Investment (ROI), to secure support from higher management. This proactive and transparent approach ensures effective communication and collaboration, mitigating potential challenges in the automation process.
Thinking that any developer or tester can handle test automation can lead to costly mistakes for organizations. Designing and implementing test automation requires a specific skill set. If a tester is doing automation, they must communicate effectively with developers and managers.
Solution:
Recognizing the specialized skill set required for test automation is important. Organizations should avoid the belief that any developer or tester can handle automation. Instead, hiring testers with specific skills needed for designing and implementing test automation can be effective.
A common cause of test automation failure is having unrealistic expectations. Sometimes, management wants the QA team to automate everything, but aiming for 100% automation isn't realistic. Certain aspects require human intervention to prevent errors and ensure timely software releases.
Solution:
To overcome unrealistic expectations, the QA teams must set achievable automation goals, educate stakeholders about the limitations of full automation, prioritize critical test cases, and maintain open communication to manage expectations effectively.
Automating tasks that involve Captcha and OTP, like payment gateways or new account registration, is challenging because these codes are unique each time. This challenge highlights that achieving 100% automation is impossible, and manual testing will always be needed, especially in scenarios involving Captcha and OTP.
Solution:
To overcome such challenges, the tester can automate all other aspects but allows manual intervention for steps requiring Captcha or OTP input, making use of mock services for simulation and creating separate test environments to exclude tasks like predictable elements like Captcha and OTP can enhance the overall testing strategy. A collaborative approach between automation and manual testing teams ensures a balanced strategy, combining automation for certain aspects and manual intervention where necessary.
Explore this video tutorial on how to handle Captcha while you are performing automation testing.
Reporting is crucial in testing, serving as a communication bridge between developers and testers. Selenium lacks robust reporting capabilities, posing a challenge for automation testers. The generation and maintenance of reports become critical challenges.
Solution:
Automation testers often rely on programming language-based frameworks for improved code designs and reporting to overcome this. Examples include Java frameworks like TestNG and Gauge, while the Pytest framework can be considered for Python. These frameworks enhance reporting capabilities and facilitate effective communication between development and testing teams.
Creating automation tests involves more than choosing the right tool; it requires a proper testing approach, which is challenging for testers and developers.
Testers and developers must address crucial questions:
The dynamic nature of applications in Agile development adds complexity, requiring strategies to identify and adapt to changes with minimal maintenance effort. Finding a solution that automatically updates tests in response to evolving applications without human intervention is demanding.
Solution:
Testers and developers must minimize script implementation and maintenance efforts by adopting modular design and testing frameworks that support easy updates.
Ensuring the long-term effectiveness of automation test suites involves regular reassessment, updates aligned with application changes, and using version control systems to track modifications.
Generating valuable test reports and metrics requires implementing reporting tools within the chosen framework, with clear metric goals and periodic reviews for optimization. Embracing Agile testing practices and a robust version control system helps adapt to the dynamic nature of applications in Agile development.
CI/CD pipelines can intelligently adapt to changes for independent test updates, ensuring a streamlined and effective automation testing process.
If you need more clarification on other testing approaches, explore this guide on test approaches and get a detailed guide on their types, best practices, examples, and more.
Testing web applications across different browsers can be challenging because they may not behave the same way on each one. While checking popular browsers like Chrome, Firefox, Safari, Edge, and IE is important, the challenge goes beyond that. Testers must ensure compatibility with various browser versions, operating systems, and screen resolutions.
This complexity is what makes cross-browser testing a vital part of test automation. Testers must address this challenge to ensure the smooth functioning of the application across diverse browser environments.
Solution:
Testing across different versions of these browsers is crucial to ensure compatibility across diverse user environments. Leveraging browser automation tools such as Selenium, which supports multiple browsers, simplifies the scripting process for various testing scenarios. To scale the browser automation testing tool, use LambdaTest, which provides access to a broad range of browser and operating system combinations, facilitating comprehensive testing.
Additionally, considering different screen resolutions ensures responsive design and compatibility across various devices. Implementing these strategies enhances the effectiveness of cross-browser testing in the context of test automation.
Automating websites with dynamic content, especially for e-commerce platforms with changing catalogs and region-specific information, can be tricky for Selenium users. The challenge arises from the dynamic nature of the content, potentially causing issues with locators and delays due to AJAX-based interactions.
Solution:
Selenium provides solutions with features like Implicit and Explicit waits to manage dynamic content loading. Users can also create custom XPath expressions for effective interaction with dynamic web elements, making it possible to navigate through evolving information seamlessly.
Explore this guide and learn more about how you can handle dynamic web elements when performing automation testing on any software application.
When running tests that use outdated data, automation can lead to common mistakes and produce inaccurate results. To prevent such issues, team alignment and clear communication are crucial. In Automation and DevOps, quick responses from testers are essential for data accuracy. Achieving testing accuracy relies on maintaining data relevancy and precision. Quality assurance teams should also focus on developing robust analytical solutions to enhance overall productivity.
Solution:
To address this challenge, teams can implement regular data updates, effective communication channels, and proactive responses from testers to ensure data accuracy in automated testing processes. Developing and using robust analytical solutions by QA teams can further enhance productivity and accuracy in testing efforts.
Automation testers often face challenges with false positive and false negative results. False positives occur when test cases show errors despite the application working fine, while false negatives happen when tests pass even though there are bugs in the application. This flakiness creates confusion and a communication gap between the testing and development teams.
Solution:
To address flakiness, it's crucial to organize and manage test plans, test cases, and the testing environment systematically and appropriately. This helps in reducing misleading results and enhances the effectiveness of automated testing.
One primary reason for our automation scripts failing is synchronization problems. These occur when testers anticipate a certain event, but it gets delayed or doesn't happen as expected. For instance, when running a script, we may expect an "accept/decline cookies" prompt after launching a website, but due to delays or other reasons, it may not appear, leading to script failure.
To learn how to handle cookies while performing automation testing, refer to this video tutorial on how to handle cookies and get detailed particle knowledge.
Solution:
To address this, we commonly use Selenium's defined waits, such as Implicit and Explicit waits, which help manage synchronization issues during script execution. To learn more about waits, follow this guide on Selenium Waits, which will provide valuable insights with examples for better understanding.
Selecting the appropriate testing tool can be challenging, given the variety of options, ranging from free tools like Selenium, Cypress, and Playwright to paid ones like TestComplete. Vendors sometimes exaggerate the capabilities of their products, suggesting they are a perfect fit for every situation. This can be confusing, particularly when choosing tools without thorough research and evaluation. To make a wise decision, it's crucial to establish specific criteria based on the application and insights from experienced users.
Solution:
Conduct a thorough assessment by defining specific testing requirements. Explore and trial various tools, considering community feedback and engage with vendors. Test small projects and evaluate costs, scalability, and integration capabilities. Prioritize training and support quality, and validate tool effectiveness through a proof of concept. Adopt an iterative approach, making adjustments based on evolving testing needs and user feedback.
Ensuring thorough testing for applications across various devices, browsers, and operating systems is a significant challenge for both web and mobile platforms. Users access apps through various OS and platform combinations on different devices, highlighting the need for a robust test automation approach to achieve comprehensive coverage and maintain reliability.
Solution:
Use LambdaTest to overcome this challenge; this platform allows you to access a wide range of real devices, browsers, and OS configurations, making it easier to conduct thorough testing across diverse environments. Furthermore, prioritizing test cases based on critical devices and OS combinations enhances efficiency and maximizes coverage.
Testing complex applications in various environments, especially with regression tests, is time-consuming. Clients, however, expect quicker product deliveries to stay competitive. This pressure often leads to rushed testing, prioritization issues, and insufficient test coverage, allowing bugs to reach production.
Solution:
To address this, teams should plan and prioritize test cases, evaluating which ones benefit from automation and which require manual execution. Striking a balance between manual and automated testing is key to success. Prioritizing tests helps identify critical areas early, saving time and ensuring thorough testing. Implementing these solutions not only tackles challenges effectively but also streamlines development and testing efforts for the timely delivery of robust applications.
Having inadequate testing infrastructure and maintaining the test infrastructure can be challenging. Consider LambdaTest to provide a scalable and efficient solution to deal with inadequate testing infrastructure by allowing teams to focus on strategic test planning and execution without the burden of managing testing infrastructure. This ensures timely and robust product deliveries while meeting client expectations.
Use HyperExecute, the quickest end-to-end test orchestration cloud by LambdaTest, to execute automation tests 70% faster than any testing cloud.
Running your test scripts on the test execution platform is a breeze. With all these features of LambdaTest, you can bring down the test execution time. You can also track the issues and sort them out effectively.
While interacting with a web application, various types of popups and alerts may appear. Examples include browser-level notifications like camera or microphone access requests, web-based alerts such as site notifications or prompts to leave a site, and OS-level pop-ups that Selenium can't directly handle.
Solution:
For handling browser-level notifications, use ChromeOptions for Chrome and FirefoxOptions/FirefoxProfile for Firefox. Web-based alerts can be managed using Selenium's built-in Alerts class with methods like accept() and dismiss(). However, Selenium can't directly handle OS-level pop-ups. For such cases, where pop-ups are considered flash objects, the Robot class is commonly used to interact with them. Combining these approaches is essential to handle different types of web testing pop-ups effectively.
Learn more about handling alerts() and popups() in Selenium and other Selenium WebDriver commands and how you can handle these commands effectively by exploring this tutorial on Selenium WebDriver.
Adding more tests slows down the automation testing process, causing delays, missed milestones, and disruptions in release cycles. It's crucial to prioritize test cases to improve regression testing efficiency.
Solution:
To address this challenge, consider increasing simultaneous test executions or prioritizing which tests to automate first. Prioritization introduces questions about daily, weekly, or less frequent test execution and potential test optimizations for speed. Finding a balance between quality standards, resource conservation, and test case prioritization is challenging but essential for maintaining software reliability within specified timelines.
Now that you have learned almost all about automated testing, it’s time to learn some of its best practices in the following section.
In this section, we will discuss the best practices for automated testing to get the most out of it.
Decide the test cases that might require automation
It’s impossible to automate every test. You need to check what test automation requirements are before automating. Hence, you must sit with your team and prioritize the test cases you need to automate. First, you must set a goal and determine the tests you need to automate.
It’s strongly suggested that you check the app functionality as soon as you add it. You can also take some time to organize your smaller tests into more significant automation tests. Organizing automated tests based on the functionality and major or minor application division is also recommended.
Choose the best automated testing tool
Which testing tool do you need to learn about? This is an answer everyone needs to know, right from beginners who are starting to seek an answer to the question. Even though there are plenty of automation and UI automated testing tools in the market, the tool you choose should be good enough to simplify your tasks and give you the break you need.
Allocate testing tasks wisely
Know your team's strengths before allocating the tasks. For example, a few team members might be more vital when they write automated test scripts. A few of them might do well when asked to write test cases. Some may excel at writing test reports. Hence, it’s always good to know what your team is good at. To ensure that this happens, team communication is a must. If these tools are integrated with project management tools such as Jira integration and Slack integration, they will help you out, in the long run, to keep your team communication smoother.
High-quality Test Data is mandatory
Test data is mandatory for data driven framework testing. The input data is usually stored as a part of an external file. You can read the data from a database or other sources such as tables, Excel sheets, XML, or text files. The best tool is the one that gets a clear gist of the data file and content and iterates the content while performing automation testing. When you leverage external data, these automation tests become reusable and easy to maintain.
To know what more best practices to follow when working with automation testing, refer to this guide best practices for automation Selenium and get valuable insights and a basic idea on what approach should be taken when starting with automation
Test Automation is a crucial component of the software development life cycle as it helps to ensure the dependability and quality of software applications. Testing teams can enhance accuracy, cut expenses, and increase efficiency by automating time-consuming, repetitive tasks. In today's digital environment, when consumers access apps from several devices and locations, automation tests enable teams to test their applications across different platforms, browsers, and devices. It assists in increasing the software quality and the end-user experience with thorough planning and execution.
On this page
Did you find this page helpful?
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!